home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Mac Game Programming Gurus / TricksOfTheMacGameProgrammingGurus.iso / More Source / C⁄C++ / Rotater 2.8 / source / Rotater.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-07  |  79.1 KB  |  3,532 lines  |  [TEXT/MPCC]
  1. /*************************************************************
  2. *
  3. *   Rotater 2.8 Source Code
  4. *
  5. *   This program reads a set of 3D points from a file and
  6. *   then displays them in a window where they can be rotated
  7. *   around using the track-ball method in real time.
  8. *
  9. *   Feel free to use chunks of this code.
  10. *   I retain the copyright for the whole.
  11. *
  12. *   The project files are for CW5.
  13. *
  14. *   I just do this for fun so the code here may not represent
  15. *   the best way to do things. It just works for me :-)
  16. *
  17. *
  18. *   Craig Kloeden
  19. *   craig@raru.adelaide.edu.au
  20. *   7 May 1995
  21. *
  22. *************************************************************/
  23.  
  24. #include "InfWin.h"
  25. #include <QDOffscreen.h>
  26. #include <math.h>
  27. #include <stdio.h>
  28. #include <stdlib.h>
  29. #include <EPPC.h>
  30. #include <AppleEvents.h>
  31. #include <GestaltEqu.h>
  32. #include <Folders.h>
  33. #include <console.stubs.c>
  34. #include <string.h>
  35.  
  36. #define    DEGTORAD  0.01745329252
  37.  
  38. void    main (void);
  39. void    init (void);
  40. void    HandleEvent (void);
  41. void    HandleMouseDown (EventRecord *theEvent);
  42. void    HandleMenu (long mSelect, long mods);
  43. void    finishup (void);
  44. void    mousepress (Point p);
  45. void    giveicon (void);
  46. void    getuserfile (void);
  47. void    readfile (FSSpec theFSS);
  48. void    startball (void);
  49. void    goball (void);
  50. void    installAEhandlers (void);
  51. void    DoHighLevelEvent (EventRecord *theEvent);
  52. pascal    OSErr    openAE (AppleEvent *theEvent, AppleEvent *reply, long refcon);
  53. pascal    OSErr    quitAE (AppleEvent *theEvent, AppleEvent *reply, long refcon);
  54. pascal    OSErr    printAE (AppleEvent *theEvent, AppleEvent *reply, long refcon);
  55. pascal    OSErr    startAE (AppleEvent *theEvent, AppleEvent *reply, long refcon);
  56. void    info (void);
  57. void    died (char desc[255], int code, int ref);
  58. void    keyrotate (char ch, Boolean rep);
  59. void    rotate (void);
  60. void    rotatestereo (void);
  61. void    rotatemono (void);
  62. void    adjustsize (void);
  63. void    plotline (long x, long x1, long y, long y1, long bytecol);
  64. void    plot_hiddenline (long x, long x1, long y, long y1, long bytecol, long ughx, long ugh1x);
  65. void    doclose(void);
  66. void    resetimage (void);
  67. void    copyimage (void);
  68. void    vectorcopy (void);
  69. void    savepict (Boolean vector);
  70. void    readprefs (void);
  71. void    writeprefs (void);
  72. void    rotatestereoRB (void);
  73. void    plotlineRB (Byte col, Byte mix, Byte bkgd, long XX, long XX1, long YY, long YY1);
  74. void    updatemenus (void);
  75. void    cooldot (long XX, long YY, long col, double dep, long ugh);
  76. void    moveit (double amt);
  77. void    centerimage (void);
  78. void    maxwindowsize (void);
  79. void    setdpi (void);
  80. void    showangles (void);
  81.  
  82. #ifdef powerc
  83. void    bzero(void *s, int n); // courtesy of tim@apple.com (Tim Olson)
  84. #else
  85. #define bzero(ptr,size) memset(ptr,0,size)
  86. #endif
  87.  
  88. long MAXwidth;
  89. long MAXheight;
  90. Byte *plane;
  91. struct    Aray { double a[3]; };
  92. struct    Aray    *aaa;
  93. struct    pars
  94.     {
  95.     long WINleft, WINtop, WINright, WINbottom, PERSPEC;
  96.     long DEPTHcue, COLOR, WBACK, CHIR, STEREO, PARALLEL;
  97.     long STangle, STsep;
  98.     long dpi, KIND, GRAB, BIGDOTS;
  99.     long LINE, HIDDEN;
  100.     long INFO, INFOleft, INFOtop;
  101.     long FUNKY;
  102.     long MAXwidth, MAXheight;
  103.     long ROTYPE, SHANGS;
  104.     };
  105. struct    pars PARS;
  106.  
  107. long    *cc;
  108. long    MaxPoints = 0;
  109. double    Xangle, Yangle, Zangle, zoom = 1;
  110. long    N;
  111. Boolean    done;
  112. Rect    frameRect, frameRectDPI, dragRect, maxrect;
  113. Rect    GRect, picrec, inforec;
  114. CWindowPtr    thewindow;
  115. WindowPtr    infowindow;
  116. GWorldPtr    drawWorldP;
  117. PixMapHandle    thePixMapH, windowPixMapH;
  118. PixMapPtr    drawPixMapP, windowPixMapP;
  119. MenuHandle    applemenu, filemenu, editmenu, viewmenu, stereomenu, actionmenu,
  120.             infomenu, anglemenu, persmenu, dotmenu, linemenu;
  121. GWorldPtr    saveWorld;
  122. GDHandle    saveDevice;
  123. OSErr    err;
  124. RGBColor    black = {0,0,0}, white = {65535, 65535, 65535};
  125. RGBColor    red = {65535, 0, 0}, green = {0, 65535, 0}, blue = {0, 0, 65535};
  126. RGBColor    yellow = {65535, 65535, 0}, purple = {65535, 0, 65535};
  127. RGBColor    cyan = {0, 65535, 65535};
  128. RGBColor    acol[8], tcol;
  129. RGBColor    vcol[8][12];
  130. Byte    *base;
  131. Byte    Bred [8][11][16][16], bcol[8][12];
  132. Byte    STred, STblue, STgreen, STredblue, STredgreen, STwhite, STblack;
  133. Byte    STWred, STWgreen, STWblue, STWredblue, STWredgreen;
  134. long    rb;
  135. long    Nspace;
  136. long    Wwidth, Wheight, Wmiddle, W2middle;
  137. long    ddd;
  138. long    comW, comH;
  139. long    comn = 0;
  140. unsigned long    cn, ct;
  141. char    errdes[50];
  142. char    comments[2001];
  143. double    dep;
  144. PicHandle    redpic;
  145. PicHandle    thepic;
  146. CursHandle    curshan[8];
  147. FSSpec    myFSS;
  148. Boolean    hasicon = TRUE, gotdots;
  149. Str255    infoTitle = "\pInfo";
  150.  
  151. //************************************************************************
  152.  
  153. void main (void)
  154. {
  155.     init ();
  156.     
  157.     done = false;
  158.     
  159.     while (!done)
  160.         HandleEvent();
  161.     
  162.     finishup ();
  163. }
  164.  
  165. //************************************************************************
  166.  
  167. void init (void)
  168. {
  169.     EventRecord tempEvent;
  170.     long i, j, k, kk;
  171.     long tt;
  172.     Size siz;
  173.     long gesres;
  174.     GDHandle devhan;
  175.     Boolean dep8;
  176.     
  177.     /* Initialize Managers */
  178.     InitGraf (&qd.thePort);
  179.     InitFonts ();
  180.     FlushEvents(everyEvent - osMask - diskMask, 0);
  181.     InitWindows ();
  182.     InitMenus ();
  183.     TEInit ();
  184.     InitDialogs (nil);
  185.     InitCursor ();
  186.     MaxApplZone();
  187.     MoreMasters();
  188.     MoreMasters();
  189.     MoreMasters();
  190.     
  191.     EventAvail(everyEvent, &tempEvent);
  192.     EventAvail(everyEvent, &tempEvent);
  193.     EventAvail(everyEvent, &tempEvent);
  194.     
  195.     /* set up menus */
  196.     applemenu = GetMenu(128);
  197.     if (applemenu == NULL) died ("Can't find Apple Menu Resource", 0, 1);
  198.     AddResMenu(applemenu, 'DRVR');
  199.     filemenu = GetMenu(129);
  200.     editmenu = GetMenu(130);
  201.     viewmenu = GetMenu(131);
  202.     stereomenu = GetMenu(132);
  203.     actionmenu = GetMenu(133);
  204.     infomenu = GetMenu(134);
  205.     anglemenu = GetMenu(200);
  206.     persmenu = GetMenu(201);
  207.     dotmenu = GetMenu(202);
  208.     linemenu = GetMenu(203);
  209.     InsertMenu(applemenu, 0);
  210.     InsertMenu(filemenu, 0);
  211.     InsertMenu(editmenu, 0);
  212.     InsertMenu(viewmenu, 0);
  213.     InsertMenu(stereomenu, 0);
  214.     InsertMenu(actionmenu, 0);
  215.     InsertMenu(infomenu, 0);
  216.     // sub menus
  217.     InsertMenu(anglemenu, -1);
  218.     InsertMenu(persmenu, -1);
  219.     InsertMenu(dotmenu, -1);
  220.     InsertMenu(linemenu, -1);
  221.     
  222.     DrawMenuBar();
  223.     
  224.     dragRect = qd.screenBits.bounds;
  225.     
  226. #if __MC68881__ // building for 881
  227.  
  228.     // Check for FPU
  229.     Gestalt(gestaltFPUType, &gesres);
  230.     if (gesres == gestaltNoFPU)
  231.         died ("Cannot find FPU", gesres, 2);
  232.  
  233. #endif
  234.     
  235.     // Check for System 7
  236.     Gestalt(gestaltSystemVersion, &gesres);
  237.     if (gesres < (0x700 & 0x0000FFFF))
  238.         died ("System 7 or greater is REQUIRED", gesres, 3);
  239.  
  240.     // Check for 32 bit quickdraw
  241.     Gestalt(gestaltQuickdrawVersion, &gesres);
  242.     if (gesres < gestalt32BitQD)
  243.         died ("No 32 bit quickdraw found", gesres, 4);
  244.     
  245.     // check for any 8 bit deep screen
  246.     devhan = GetDeviceList();
  247.     dep8 = FALSE;
  248.     while (devhan)
  249.         {
  250.         if ((**((**devhan).gdPMap)).pixelSize == 8) dep8 = TRUE;
  251.         devhan = GetNextDevice(devhan);
  252.         }
  253.     if (!dep8) // no 8 bit screen around
  254.         {
  255.         Alert(132,NULL); // tell user 8 bits is good to use
  256.         }
  257.     
  258.     /* no points yet */
  259.     N = 0;
  260.       
  261.     /* set up the main window */
  262.     thewindow = (CWindowPtr) GetNewCWindow (400, nil, (WindowPtr)-1L);
  263.     if (thewindow == NULL) died ("Can't get Window Resource", 0, 5);
  264.     SetPort ((WindowPtr)thewindow);
  265.     GetGWorld(&saveWorld, &saveDevice);
  266.     windowPixMapH = GetGWorldPixMap(saveWorld);
  267.     
  268.     // set up floating info window
  269.     SetRect (&inforec, 50, 50, 295, 130);
  270.     infowindow = NewWindow(nil, &inforec, infoTitle, FALSE, kInfinityProc,
  271.         (WindowPtr)-1L, TRUE, 128);
  272.       
  273.     // read preference file
  274.     readprefs();
  275.     
  276.     // check if option key is down
  277.     GetOSEvent(everyEvent, &tempEvent);
  278.   if ((tempEvent.modifiers & optionKey) != 0)
  279.       maxwindowsize(); // set the max window size
  280.   
  281.     MAXwidth = PARS.MAXwidth;
  282.     MAXheight = PARS.MAXheight;
  283.     
  284.     // place windows on screen
  285.     if (PARS.WINright-PARS.WINleft >= MAXwidth)
  286.         PARS.WINright = PARS.WINleft + MAXwidth - 1;
  287.     if (PARS.WINbottom-PARS.WINtop >= MAXheight)
  288.         PARS.WINbottom = PARS.WINtop + MAXheight - 1;
  289.     MoveWindow ((WindowPtr)infowindow, PARS.INFOleft, PARS.INFOtop, TRUE);
  290.     MoveWindow ((WindowPtr)thewindow, PARS.WINleft, PARS.WINtop, TRUE);
  291.     SizeWindow ((WindowPtr)thewindow, PARS.WINright-PARS.WINleft,
  292.         PARS.WINbottom-PARS.WINtop, TRUE);
  293.     adjustsize();
  294.     
  295.     // map of screen pixels for hidden line stuff
  296.     plane = (Byte *) NewPtr(MAXwidth*MAXheight);
  297.     if (!plane) died ("Could not assign storage", 0, 6);
  298.     SetRect (&maxrect, 99, 99 , MAXwidth, MAXheight);
  299.     SetRect (&GRect, 0, 0 , MAXwidth, MAXheight);
  300.     
  301.     // set up offscreen GWorld
  302.     err = NewGWorld(&drawWorldP, 8, &GRect, nil, nil, keepLocal);
  303.     if (err) died ("Could not Create GWorld", err, 7);
  304.     thePixMapH = GetGWorldPixMap(drawWorldP);
  305.     HLockHi((Handle)thePixMapH);
  306.     LockPixels(thePixMapH);
  307.     drawPixMapP = *thePixMapH;
  308.     
  309.     //    base = (Byte *) GetPixBaseAddr(thePixMapH);
  310.     base = (Byte*) (*thePixMapH)->baseAddr; // for 7.0
  311.     rb = (*thePixMapH)->rowBytes & 0x1fff; // high 3 bits are flags
  312.     
  313.     SetGWorld(drawWorldP, nil);
  314.     TextFont (geneva);
  315.     TextSize (9);
  316.  
  317.     // read in, draw and load ball pixels into array
  318.     SetRect (&picrec, 0, 0, 88, 56);
  319.     redpic = GetPicture (129);
  320.     DrawPicture (redpic, &picrec);
  321.     ReleaseResource ((Handle)redpic);
  322.     for (kk=1;kk<=7;kk++)
  323.         for (i=0;i<=10;i++)
  324.             for (j=0;j<=7;j++)
  325.                 for (k=0;k<=7;k++)
  326.                     Bred[kk][i][j][k] = base[rb*(k+kk*8-8) + j + i*8];
  327.     
  328.     // set up the colors
  329.     StdRect((PARS.WBACK) ? erase : paint,&frameRect);
  330.     acol[1] = red;
  331.     acol[2] = green;
  332.     acol[3] = blue;
  333.     acol[4] = yellow;
  334.     acol[5] = purple;
  335.     acol[6] = cyan;
  336.     acol[7] = white;
  337.      for (i=1;i<8;i++)
  338.          {
  339.          vcol[i][10] = white;
  340.          vcol[i][11] = black;
  341.          bcol[i][10] = Color2Index(&white);
  342.          bcol[i][11] = Color2Index(&black);
  343.          bcol[i][9] = Color2Index(&acol[i]);
  344.          vcol[i][9] = acol[i];
  345.          for (j=8;j>=0;j--)
  346.              {
  347.              tt = acol[i].red;
  348.              tt = tt * ((65535-20000)*j/9 + 20000) / 65535;
  349.              tcol.red = tt;
  350.              tt = acol[i].green;
  351.              tt = tt * ((65535-20000)*j/9 + 20000) / 65535;
  352.              tcol.green = tt;
  353.              tt = acol[i].blue;
  354.              tt = tt * ((65535-20000)*j/9 + 20000) / 65535;
  355.              tcol.blue = tt;
  356.              vcol[i][j] = tcol;
  357.              bcol[i][j] = Color2Index(&tcol);
  358.              }
  359.          }
  360.      STblack = bcol[1][11];
  361.      STwhite = bcol[1][10];
  362.      STred = bcol[1][3];
  363.      STgreen = bcol[2][1];
  364.      STblue = bcol[3][9];
  365.      STredblue = bcol[5][9];
  366.      STredgreen = bcol[4][3];
  367.      STWred = Color2Index(&red);
  368.      STWgreen = Color2Index(&green);
  369.      STWblue = Color2Index(&blue);
  370.      STWredblue = Color2Index(&black);
  371.      STWredgreen = Color2Index(&black);
  372.      
  373.     SetGWorld(saveWorld, saveDevice);
  374.     
  375.     /* get beachball cursors */
  376.     for (i=0;i<8;i++)
  377.         curshan[i] = GetCursor (256+i);
  378.     
  379.       /* install apple event handlers */
  380.       installAEhandlers ();
  381.       
  382.       /* assign array memory */
  383.       siz = CompactMem (20000000);
  384.       /* save 200000 bytes for pictures and dialogs */
  385.       if (siz < 200000) died ("Not Enough Memory to Run", siz, 8);
  386.       Nspace = sizeof(struct Aray) + sizeof(long);
  387.       MaxPoints = (siz-200000) / Nspace;
  388.     
  389.     // the points array space
  390.     aaa = (struct Aray *) NewPtr(MaxPoints*sizeof(struct Aray));
  391.     if (!aaa) died ("Could not assign storage", 0, 9);
  392.     
  393.     // the colors array space
  394.     cc = (long*) NewPtr(MaxPoints*sizeof(long));
  395.     if (!cc) died ("Could not assign storage", 0, 10);
  396.     
  397.     // show info window if needed
  398.     if (PARS.INFO)
  399.         {
  400.         ShowWindow (infowindow);
  401.         info();
  402.         }
  403. }
  404.  
  405. //************************************************************************
  406.  
  407. void HandleEvent(void)
  408. {
  409.     EventRecord    theEvent;
  410.     char ch;
  411.     
  412.     HiliteMenu(0);
  413.     
  414.     if (WaitNextEvent (everyEvent, &theEvent, 50, NULL))
  415.     switch (theEvent.what)
  416.         {
  417.         case mouseDown:
  418.             HandleMouseDown(&theEvent);
  419.         break;
  420.             
  421.         case keyDown: 
  422.             if ((theEvent.modifiers & cmdKey) != 0)
  423.                     {
  424.                     HandleMenu(MenuKey((char) (theEvent.message & charCodeMask)), theEvent.modifiers);
  425.                     if ((char) (theEvent.message & charCodeMask) == '=')
  426.                         keyrotate('+', FALSE);
  427.                     }
  428.             else keyrotate(theEvent.message & charCodeMask, FALSE);
  429.         break;
  430.         
  431.         case autoKey:
  432.             ch = theEvent.message & charCodeMask;
  433.         if ((theEvent.modifiers & cmdKey) != 0)
  434.               {
  435.               // repeat these menu keys
  436.               if (ch == '-' || ch == '+' || ch == '7' || ch == '9' ||
  437.                   ch == '4' || ch == '6' || ch == '1' || ch == '3')
  438.                   keyrotate(ch, TRUE);
  439.               // treat '=' as a '+'
  440.               if (ch == '=') keyrotate('+', TRUE);
  441.                 }
  442.             else
  443.                 {
  444.                 if (ch != 'H' && ch != 'h')
  445.                     keyrotate(ch, TRUE);
  446.                 }
  447.         break;
  448.             
  449.         case updateEvt:
  450.             if ( (WindowPtr)(theEvent.message) == infowindow)
  451.                 {
  452.                 BeginUpdate((WindowPtr)infowindow);
  453.                 if (PARS.INFO) info();
  454.                 EndUpdate((WindowPtr)infowindow);
  455.                 }
  456.             else
  457.                 {
  458.                 BeginUpdate((WindowPtr)thewindow);
  459.                 /* copy GWorld to screen window */
  460.                 SetGWorld(saveWorld, saveDevice);
  461.                 CopyBits((BitMapPtr)drawPixMapP, (BitMapPtr)windowPixMapP,
  462.                     &frameRect, &frameRect, srcCopy, nil);
  463.                 EndUpdate((WindowPtr)thewindow);
  464.                 }
  465.           break;
  466.             
  467.         case activateEvt:
  468.             InvalRect(&thewindow->portRect);
  469.             InvalRect(&infowindow->portRect);
  470.         break;
  471.             
  472.         case osEvt:
  473.             if (theEvent.message & 1) /* Resume Event */
  474.                 {
  475.                 InitCursor();
  476.                 HiliteWindow ((WindowPtr)thewindow, TRUE);
  477.                 }
  478.             else /* Suspend Event */
  479.                 {
  480.                 InitCursor();
  481.                 HiliteWindow ((WindowPtr)thewindow, FALSE);
  482.                 }
  483.         break;
  484.             
  485.         case kHighLevelEvent:
  486.             DoHighLevelEvent (&theEvent);
  487.         break;
  488.         }
  489.     else /* null event */
  490.         {
  491.         }
  492. }
  493.  
  494. //************************************************************************
  495.  
  496. void HandleMouseDown (EventRecord *theEvent)
  497. {
  498.     WindowPtr    awindow;
  499.     int            windowCode = FindWindow (theEvent->where, &awindow);
  500.     long        growsize;
  501.     
  502.     switch (windowCode)
  503.         {
  504.         case inSysWindow: 
  505.             SystemClick (theEvent, awindow);
  506.         break;
  507.         
  508.         case inMenuBar:
  509.             HandleMenu(MenuSelect(theEvent->where), theEvent->modifiers);
  510.         break;
  511.         
  512.         case inDrag:
  513.             if (awindow == (WindowPtr)thewindow)
  514.                 {
  515.                 DragWindow((WindowPtr)thewindow, theEvent->where, &dragRect);
  516.                 if (PARS.INFO)
  517.                     {
  518.                     BringToFront (infowindow);
  519.                     HiliteWindow (infowindow, TRUE);
  520.                     }
  521.                 }
  522.             else if (awindow == (WindowPtr)infowindow)
  523.                 {
  524.                 DragWindow((WindowPtr)infowindow, theEvent->where, &dragRect);
  525.                 info();
  526.                 }
  527.             adjustsize();
  528.             rotate();
  529.         break;
  530.         
  531.         case inZoomIn:
  532.         case inZoomOut:
  533.             if (TrackBox ((WindowPtr)thewindow, theEvent->where, windowCode))
  534.                 {
  535.                 // Max out the window
  536.                 HideWindow ((WindowPtr)thewindow);
  537.                 UnlockPixels(windowPixMapH);
  538.                 ZoomWindow ((WindowPtr)thewindow, windowCode, FALSE);
  539.                 Wwidth = (thewindow->portRect).right - (thewindow->portRect).left;
  540.                 Wheight = (thewindow->portRect).bottom - (thewindow->portRect).top;
  541.                 if (Wwidth > MAXwidth || Wheight > MAXheight)
  542.                     SizeWindow ((WindowPtr)thewindow, MAXwidth-1, MAXheight-1, TRUE);
  543.                 if (theEvent->modifiers & optionKey) // check for option key
  544.                     {
  545.                     Wwidth = (thewindow->portRect).right - (thewindow->portRect).left;
  546.                     Wheight = (thewindow->portRect).bottom - (thewindow->portRect).top;
  547.                     if (PARS.STEREO && PARS.KIND<3)
  548.                         {
  549.                         if (Wwidth < Wheight*2) Wheight = Wwidth/2;
  550.                         else Wwidth = Wheight*2;
  551.                         }
  552.                     else
  553.                         {
  554.                         if(Wwidth<Wheight) Wheight=Wwidth;
  555.                         else Wwidth=Wheight;
  556.                         }
  557.                     SizeWindow ((WindowPtr)thewindow, Wwidth, Wheight, TRUE);
  558.                     }
  559.                 ShowWindow ((WindowPtr)thewindow);
  560.                 adjustsize();
  561.                 rotate();
  562.                 }
  563.         break;
  564.         
  565.         case inGrow:
  566.             DrawGrowIcon((WindowPtr)thewindow);
  567.             growsize = GrowWindow ((WindowPtr)thewindow, theEvent->where, &maxrect);
  568.             if (growsize)
  569.                 {
  570.                 // resize the window
  571.                 UnlockPixels(windowPixMapH);
  572.                 if (LoWord(growsize) <= MAXwidth && HiWord(growsize) <= MAXheight)
  573.                     SizeWindow ((WindowPtr)thewindow, LoWord(growsize),
  574.                         HiWord(growsize), TRUE);
  575.                 adjustsize();
  576.                 }
  577.             rotate();
  578.         break;
  579.         
  580.         case inContent:
  581.             if (awindow == (WindowPtr)thewindow)
  582.                 {
  583.                 GlobalToLocal(&theEvent->where);
  584.                 mousepress (theEvent->where);
  585.                 }
  586.             else if (awindow == (WindowPtr)infowindow)
  587.                 {
  588.                 SelectWindow((WindowPtr)infowindow);
  589.                 }
  590.         break;
  591.           
  592.         case inGoAway:
  593.           if (awindow == (WindowPtr)thewindow && 
  594.               TrackGoAway((WindowPtr)thewindow, theEvent->where))
  595.                   doclose();
  596.         if ((awindow == infowindow) && TrackGoAway(infowindow, theEvent->where))
  597.             {
  598.             HideWindow (infowindow);
  599.             PARS.INFO = FALSE;
  600.             updatemenus();
  601.             }
  602.         break;
  603.         }
  604. }
  605.  
  606. //************************************************************************
  607.  
  608. void HandleMenu (long mSelect, long mods)
  609. {
  610. int            menuID = HiWord(mSelect);
  611. int            menuItem = LoWord(mSelect);
  612. Str255        name;
  613. GrafPtr        savePort;
  614. long        speedi, speed1, speed2, wild, slug;
  615. Boolean        upity;
  616. char        a[50], b[50], c[50];
  617.  
  618. switch (menuID)
  619.     {
  620.     case 128: // apple menu
  621.         if (menuItem == 1) // About
  622.             {
  623.             Alert(128,NULL);
  624.             break;
  625.             }
  626.         else // system apple menu item
  627.             {
  628.             GetPort(&savePort);
  629.             GetItem(applemenu, menuItem, name);
  630.             OpenDeskAcc(name);
  631.             SetPort(savePort);
  632.             }
  633.     break;
  634.     
  635.     case 129: // file menu
  636.         switch (menuItem)
  637.             {
  638.             case 1: // open
  639.                 getuserfile();
  640.                 break;
  641.             case 2: // close
  642.                 doclose();
  643.                 break;
  644.             case 3: // Give Icon
  645.                 giveicon();
  646.                 break;
  647.             case 4: // save bitmap pict
  648.                 savepict(FALSE); // bitmap copy
  649.                 break;
  650.             case 5: // save vector pict
  651.                 if (mods & optionKey) setdpi();
  652.                 else savepict(TRUE); // vector copy
  653.                 break;
  654.             case 7: // quit
  655.                 done = true;
  656.                 break;
  657.             }
  658.     break;
  659.     
  660.     case 130: // edit menu
  661.         switch (menuItem)
  662.             {
  663.             case 2: // copy
  664.                 copyimage();
  665.                 break;
  666.             case 5: // save preferences
  667.                 writeprefs();
  668.                 break;
  669.             }
  670.     break;
  671.     
  672.     case 131: /* view menu */
  673.         switch (menuItem)
  674.             {
  675.             case 4: /* depth cueing */
  676.                 if (PARS.DEPTHcue) PARS.DEPTHcue = FALSE; else PARS.DEPTHcue = TRUE;
  677.                 updatemenus();
  678.                 rotate ();
  679.                 break;
  680.             case 5: /* hide lines */
  681.                 if (PARS.HIDDEN) PARS.HIDDEN = FALSE; else PARS.HIDDEN = TRUE;
  682.                 updatemenus();
  683.                 rotate ();
  684.                 break;
  685.             case 6: /* color */
  686.                 if (PARS.COLOR) PARS.COLOR = FALSE; else PARS.COLOR = TRUE;
  687.                 updatemenus();
  688.                 rotate ();
  689.                 break;
  690.             case 7: /* black background */
  691.                 if (PARS.WBACK) PARS.WBACK = FALSE; else PARS.WBACK = TRUE;
  692.                 updatemenus();
  693.                 rotate ();
  694.                 break;
  695.             case 8: /* funky */
  696.                 if (PARS.FUNKY) PARS.FUNKY = FALSE; else PARS.FUNKY = TRUE;
  697.                 updatemenus();
  698.                 rotate ();
  699.                 break;
  700.             case 10: /* Right handed */
  701.                 PARS.CHIR = TRUE;
  702.                 updatemenus();
  703.                 rotate ();
  704.                 break;
  705.             case 11: /* Left handed */
  706.                 PARS.CHIR = FALSE;
  707.                 updatemenus();
  708.                 rotate ();
  709.                 break;
  710.             case 13: /* Mono */
  711.                 PARS.STEREO = FALSE;
  712.                 updatemenus();
  713.                 rotate ();
  714.                 break;
  715.             case 14: /* Stereo */
  716.                 PARS.STEREO = TRUE;
  717.                 updatemenus();
  718.                 rotate ();
  719.                 break;
  720.             }
  721.     break;
  722.  
  723.     case 132: // stereo menu
  724.         switch (menuItem)
  725.             {
  726.             case 1: /* stereo crosseyed */
  727.                 PARS.KIND = 1;
  728.                 PARS.PARALLEL = FALSE;
  729.                 updatemenus();
  730.                 rotate ();
  731.                 break;
  732.             case 2: /* stereo parallel */
  733.                 PARS.KIND = 2;
  734.                 PARS.PARALLEL = TRUE;
  735.                 updatemenus();
  736.                 rotate ();
  737.                 break;
  738.             case 3: /* red blue */
  739.                 PARS.KIND = 3;
  740.                 updatemenus();
  741.                 rotate ();
  742.                 break;
  743.             case 4: /* red green */
  744.                 PARS.KIND = 4;
  745.                 updatemenus();
  746.                 rotate ();
  747.                 break;
  748.             case 7: /* increase angle */
  749.                 PARS.STangle++;
  750.                 if (PARS.STangle > 20) { SysBeep(1); PARS.STangle = 20; }
  751.                 updatemenus();
  752.                 rotate ();
  753.                 break;
  754.             case 8: /* decrease angle */
  755.                 PARS.STangle--;
  756.                 if (PARS.STangle < 0) { SysBeep(1); PARS.STangle = 0; }
  757.                 updatemenus();
  758.                 rotate ();
  759.                 break;
  760.             case 10: /* increase seperation */
  761.                 PARS.STsep++;
  762.                 if (PARS.STsep > 40) { SysBeep(1); PARS.STsep = 40; }
  763.                 updatemenus();
  764.                 rotate ();
  765.                 break;
  766.             case 11: /* decrease seperation */
  767.                 PARS.STsep--;
  768.                 if (PARS.STsep < -40) { SysBeep(1); PARS.STsep = -40; }
  769.                 updatemenus();
  770.                 rotate ();
  771.                 break;
  772.             }
  773.     break;
  774.  
  775.     case 133: // action menu
  776.         switch (menuItem)
  777.             {
  778.             case 1: // zoom in
  779.                 zoom *= 1.01;
  780.                 rotate ();
  781.             break;
  782.             case 2: // zoom out
  783.                 zoom /= 1.01;
  784.                 rotate ();
  785.             break;
  786.             case 4: // rotation method
  787.                 if (PARS.ROTYPE == 1) PARS.ROTYPE = 2;
  788.                 else
  789.                     {
  790.                     PARS.ROTYPE = 1;
  791.                     rotate();
  792.                     }
  793.                 updatemenus();
  794.                 rotate();
  795.                 break;
  796.             case 5: // grab and spin
  797.                 if (PARS.GRAB) PARS.GRAB = FALSE; else PARS.GRAB = TRUE;
  798.                 updatemenus();
  799.                 break;
  800.             case 6: /* rotate Z-axis */
  801.                 while (! Button())
  802.                     {
  803.                     //SystemTask();
  804.                     Zangle += 2;
  805.                     rotate ();
  806.                     }
  807.                 FlushEvents(keyDownMask + keyUpMask + autoKeyMask, 0);
  808.                 break;
  809.             case 7: // wobble
  810.                 wild = 4;
  811.                 upity = TRUE;
  812.                 slug = TickCount() + 4;
  813.                 while (! Button())
  814.                     {
  815.                     while (TickCount() < slug+4) {}
  816.                     slug = TickCount();
  817.                     if (upity && wild == 4) upity = FALSE;
  818.                     else if (!upity && wild == -4) upity = TRUE;
  819.                     else if (upity) wild++;
  820.                     else wild--;
  821.                     Zangle += wild;
  822.                     rotate ();
  823.                     }
  824.                 // ignore any key presses done while wobbling
  825.                 FlushEvents(keyDownMask + keyUpMask + autoKeyMask, 0);
  826.                 break;
  827.             case 9: // center image
  828.                 centerimage();
  829.                 rotate();
  830.                 break;
  831.             case 10: // move right
  832.                 moveit (0.02);
  833.                 break;
  834.             case 11: // move left
  835.                 moveit (-0.02);
  836.                 break;
  837.             case 13: // full screen
  838.                 UnlockPixels(windowPixMapH);
  839.                 MoveWindow ((WindowPtr)thewindow, 0, 20, TRUE);
  840.                 SizeWindow ((WindowPtr)thewindow, MAXwidth-1, MAXheight-1, TRUE);
  841.                 BringToFront (infowindow); //!!
  842.                 HiliteWindow (infowindow, TRUE); //!!
  843.                 adjustsize();
  844.                 rotate();
  845.                 break;
  846.             case 14: /* small window*/
  847.                 UnlockPixels(windowPixMapH);
  848.                 MoveWindow ((WindowPtr)thewindow, 10, 50, TRUE);
  849.                 if (MAXwidth < 199 || MAXheight < 199)
  850.                     SizeWindow ((WindowPtr)thewindow, MAXwidth-1, MAXheight-1, TRUE);
  851.                 else
  852.                     SizeWindow ((WindowPtr)thewindow, 199, 199 , TRUE);
  853.                 BringToFront (infowindow); //!!
  854.                 HiliteWindow (infowindow, TRUE); //!!
  855.                 adjustsize();
  856.                 rotate();
  857.                 break;
  858.             case 15: /* master reset */
  859.                 resetimage();
  860.                 break;
  861.             }
  862.     break;
  863.     
  864.     case 134: // info menu
  865.         switch (menuItem)
  866.             {
  867.             case 1: /* Show Info */
  868.                 if (PARS.INFO)
  869.                     {
  870.                     PARS.INFO = FALSE;
  871.                     HideWindow (infowindow);
  872.                     }
  873.                 else
  874.                     {
  875.                     PARS.INFO = TRUE;
  876.                     ShowWindow (infowindow);
  877.                     BringToFront (infowindow);
  878.                     HiliteWindow (infowindow, TRUE);
  879.                     info();
  880.                     }
  881.                 updatemenus();
  882.                 break;
  883.                 
  884.             case 2: /* Show Angles */
  885.                 if (PARS.SHANGS) PARS.SHANGS = FALSE;
  886.                 else PARS.SHANGS = TRUE;
  887.                 updatemenus();
  888.                 rotate();
  889.                 break;
  890.                 
  891.             case 4: // run speed test
  892.                 speed1 = TickCount();
  893.                 speedi=0;
  894.                 while (speedi < 180 && !Button())
  895.                     {
  896.                     Zangle += 2;
  897.                     rotate ();
  898.                     speedi++;
  899.                     }
  900.                 speed2 = TickCount() - speed1;
  901.                 if (speed2 == 0) speed2 = 1;
  902.                 NumToString (speedi, (StringPtr)a);
  903.                 NumToString (speed2, (StringPtr)b);
  904.                 NumToString (60*speedi/speed2, (StringPtr)c);
  905.                 ParamText ((StringPtr)a, (StringPtr)b, (StringPtr)c, NULL);
  906.                 Alert(138,NULL);
  907.                 FlushEvents(everyEvent - osMask - diskMask, 0);
  908.                 break;
  909.             }
  910.     break;
  911.     
  912.     case 200: // angle menu
  913.         PARS.STangle = menuItem-1;
  914.         updatemenus();
  915.         rotate();
  916.     break;
  917.     
  918.     case 201: // perspective menu
  919.         PARS.PERSPEC = menuItem-1;
  920.         updatemenus();
  921.         rotate();
  922.     break;
  923.     
  924.     case 202: // dot size menu
  925.         PARS.BIGDOTS = menuItem;
  926.         updatemenus();
  927.         rotate();
  928.     break;
  929.     
  930.     case 203: // line width menu
  931.         PARS.LINE = menuItem;
  932.         updatemenus();
  933.         rotate();
  934.     break;
  935.     }
  936. }
  937.  
  938. //************************************************************************
  939.  
  940. void finishup (void) /* get outa here */
  941. {
  942.     ExitToShell();
  943. }
  944.  
  945. //************************************************************************
  946.  
  947. void mousepress (Point p)
  948. {
  949.     Point p1;
  950.     int x, y, x1, y1, x2, y2, x3, y3;
  951.     double xx, yy;
  952.     unsigned long tim, tim1, tim2;
  953.     
  954.     HideCursor();
  955.     
  956.     x = 0;
  957.     y = 0;
  958.     x1 = 0; x2 = 0; x3 = 0;
  959.     y1 = 0; y2 = 0; y3 = 0;
  960.     tim = 0;
  961.     tim1 = 0;
  962.     
  963.     while (StillDown()) /* loop while button held down */
  964.         {
  965.         GetMouse (&p1);
  966.         x = p.h - p1.h;
  967.         y = p.v - p1.v;
  968.         p.h = p1.h;
  969.         p.v = p1.v;
  970.         
  971.         if (x || y) /* if mouse moved since last time around */
  972.             {
  973.             if (PARS.ROTYPE == 1)
  974.                 {
  975.                 Zangle = -x;
  976.                 Xangle = -y;
  977.                 }
  978.             else
  979.                 {
  980.                 Zangle -= x;
  981.                 Xangle -= y;
  982.                 }
  983.             tim1 = TickCount();
  984.             rotate ();
  985.             x3 = x2;
  986.             y3 = y2;
  987.             x2 = x1;
  988.             y2 = y1;
  989.             x1 = x;
  990.             y1 = y;
  991.             }
  992.         }
  993.     
  994.     ShowCursor();
  995.     
  996.     tim = TickCount();
  997.     tim = tim - tim1;
  998.     
  999.     // continue rotating the image if moved and
  1000.     // last time interval is less than 0.25 seconds (15 ticks)
  1001.     if (PARS.GRAB && (x1 || y1) && (tim < 15))
  1002.         {
  1003.         // average last 3 rotations
  1004.         xx = (x1 + x2 + x3) / 3.0;
  1005.         yy = (y1 + y2 + y3) / 3.0;
  1006.         if (xx > 10) xx = 10;
  1007.         if (xx < -10) xx = -10;
  1008.         if (yy > 10) yy = 10;
  1009.         if (yy < -10) yy = -10;
  1010.         
  1011.         #ifdef powerc
  1012.         if (PARS.ROTYPE == 2) xx = ceil(xx);
  1013.         #else
  1014.         if (PARS.ROTYPE == 2) xx = ceild(xx);
  1015.         #endif
  1016.         
  1017.         while (!Button())
  1018.             {
  1019.             // use last time interval for pacing rotations
  1020.             tim1 = TickCount();
  1021.             if (PARS.ROTYPE == 1)
  1022.                 {
  1023.                 Zangle = -xx;
  1024.                 Xangle = -yy;
  1025.                 }
  1026.             else
  1027.                 {
  1028.                 Zangle -= xx;
  1029.                 }
  1030.             rotate ();
  1031.             tim2 = TickCount();
  1032.             while ((tim2 - tim1) < tim) { tim2 = TickCount(); }
  1033.             }
  1034.         }
  1035.     FlushEvents(keyDownMask + keyUpMask + autoKeyMask, 0);
  1036. }
  1037.  
  1038. //************************************************************************
  1039.  
  1040. void giveicon (void)
  1041. {
  1042.     FInfo fin;
  1043.     
  1044.     err = FSpGetFInfo (&myFSS, &fin);
  1045.     if (err) died ("Could not Get File Info", err, 201);
  1046.     fin.fdCreator = 'KrOt'; // set creator to Rotaters type
  1047.     if (FSpSetFInfo (&myFSS, &fin))
  1048.         {
  1049.         /* couldnt change icon */
  1050.         ParamText ((StringPtr)myFSS.name, NULL, NULL, NULL);
  1051.         Alert(134,NULL);
  1052.         }
  1053.     hasicon = true;
  1054.     updatemenus();
  1055. }
  1056.  
  1057. //************************************************************************
  1058.  
  1059. void getuserfile (void)
  1060. {
  1061.     SFTypeList types;
  1062.     StandardFileReply mySFR;
  1063.     
  1064.     /* get a file record */
  1065.     types[0] = 'TEXT';
  1066.     StandardGetFile (NULL, 1, types, &mySFR);
  1067.     
  1068.     if (mySFR.sfGood)
  1069.         readfile (mySFR.sfFile);
  1070. }
  1071.  
  1072. //************************************************************************
  1073.  
  1074. void readfile (FSSpec theFSS)
  1075. {
  1076.     FILE *points;
  1077.     long    i, j, linelen, linenum;
  1078.     int        comT;
  1079.     long size = MAXwidth*MAXheight-1;
  1080.     double max, maybe;
  1081.     Byte *cp;
  1082.     FInfo fin;
  1083.     GrafPtr oldPort;
  1084.     Boolean filedone, recom;
  1085.     char aline[1001];
  1086.     char a[50];
  1087.  
  1088.     myFSS = theFSS;
  1089.     
  1090.     StdRect((PARS.WBACK) ? erase : paint,&frameRect);
  1091.     
  1092.     GetPort (&oldPort);
  1093.     SetPort (infowindow);
  1094.     EraseRect (&infowindow->portRect);
  1095.     SetPort (oldPort);
  1096.     
  1097.     // can only read TEXT files
  1098.     err = FSpGetFInfo (&myFSS, &fin);
  1099.     if (err) died ("Could not Get File Info", err, 301);
  1100.      if (fin.fdType != 'TEXT') died ("Cannot Read this File Type", err, 302);
  1101.     
  1102.     SetWTitle ((WindowPtr)thewindow, theFSS.name);
  1103.     
  1104.     startball(); // start the spinning ball
  1105.     
  1106.     // open the file
  1107.     PtoCstr((StringPtr) theFSS.name);
  1108.     err = HSetVol (NULL, theFSS.vRefNum, theFSS.parID);
  1109.     if (err) died ("Could not Set Volume", err, 303);
  1110.     points = fopen ((char *)theFSS.name, "rb");
  1111.     if (points == NULL) died ("Can't Open File", 0, 304);
  1112.     
  1113.     // read in first part of the file
  1114.     linenum = 0;
  1115.     filedone = FALSE;
  1116.     recom = TRUE;
  1117.     cp=plane;
  1118.     i=fread(cp,1,size,points); // read file (i = number of characters read)
  1119.     cp[i]=0;
  1120.     if (i == 0) filedone = TRUE; // empty file
  1121.     
  1122.     N = 0;
  1123.     comn = 0;
  1124.     comW = 0;
  1125.     comH = 0;
  1126.     
  1127.     while (!filedone)
  1128.         {
  1129.         goball();
  1130.         // get a line
  1131.         linenum++;
  1132.         linelen = 0;
  1133.         
  1134.         scanning: while (*cp && *cp != 13)
  1135.             {
  1136.             if (linelen < 1000)
  1137.                 {
  1138.                 aline[linelen] = *cp;
  1139.                 linelen++;
  1140.                 }
  1141.             cp++;
  1142.             }
  1143.         
  1144.         if (*cp == 0 && !feof(points))
  1145.             {
  1146.             cp=plane;
  1147.             i=fread(cp,1,size,points); // read more of the file (i = number of characters read)
  1148.             cp[i]=0;
  1149.             goto scanning;
  1150.             }
  1151.         
  1152.         if (*cp == 0 && feof(points)) filedone = TRUE;
  1153.         
  1154.         if (*cp == 13) cp++;
  1155.         
  1156.         // got a line in "aline"
  1157.         aline[linelen] = 0;
  1158.         
  1159.         if (aline[0] == '#') // comment line
  1160.             {
  1161.             if (recom)
  1162.                 {
  1163.                 if (comn < 2000) comH++;
  1164.                 comT = 0;
  1165.                 for (j=1;j<linelen;j++)
  1166.                     if (comn < 2000)
  1167.                         {
  1168.                         comments[comn] = aline[j];
  1169.                         comn++;
  1170.                         comT++;
  1171.                         }
  1172.                 if (comT > comW) comW = comT;
  1173.                 if (*cp == '#' && comn < 2000)
  1174.                     {
  1175.                     comments[comn] = 13;
  1176.                     comn++;
  1177.                     }
  1178.                 }
  1179.             }
  1180.         else if (aline[0]) // data line
  1181.             {
  1182.             recom = FALSE;
  1183.             if (N == MaxPoints) // too many commands
  1184.                 {
  1185.                 InitCursor();
  1186.                 NumToString (MaxPoints, (StringPtr)errdes);
  1187.                 ParamText ((StringPtr)errdes, NULL, NULL, NULL);
  1188.                 Alert(130,NULL);
  1189.                 N = 0;
  1190.                 filedone = TRUE;
  1191.                 }
  1192.             else // read command in
  1193.                 {
  1194.                 err = (sscanf(aline, "%lf %lf %lf %d", &aaa[N].a[0],
  1195.                     &aaa[N].a[1], &aaa[N].a[2], &cc[N]));
  1196.                 if (err == 4) // read line ok
  1197.                     {
  1198.                     if (cc[N] > 7) cc[N] = 7;
  1199.                     if (cc[N] < -7) cc[N] = -7;
  1200.                     N++;
  1201.                     }
  1202.                 else // error in line number "linenum"
  1203.                     {
  1204.                     InitCursor();
  1205.                     NumToString (linenum, (StringPtr)a);
  1206.                     ParamText ((StringPtr)a, NULL, NULL, NULL);
  1207.                     Alert(131,NULL);
  1208.                     N = 0;
  1209.                     filedone = TRUE;
  1210.                     }
  1211.                 }
  1212.             }
  1213.         else recom = FALSE; // blank line - stop recording comments
  1214.         }
  1215.     
  1216.     // finished reading file
  1217.     fclose (points);
  1218.     
  1219.     /* get maximum distance of points from origin */
  1220.     max = 0;
  1221.     gotdots = FALSE;
  1222.     for (i=0; i<N; i++)
  1223.         {
  1224.         maybe = sqrt(aaa[i].a[0] * aaa[i].a[0] + aaa[i].a[1] * aaa[i].a[1] +
  1225.             aaa[i].a[2] * aaa[i].a[2]);
  1226.         if (maybe > max) max = maybe;
  1227.         if (cc[i] < 0) gotdots = TRUE;
  1228.         }
  1229.     
  1230.     /* scale the points */
  1231.     if (max != 0) // cant scale points at origin
  1232.         for (i=0; i<N; i++)
  1233.             for (j=0; j<3; j++)
  1234.                 aaa[i].a[j] = (aaa[i].a[j] / max) * 0.99999;
  1235.     
  1236.     /* reset rotation angles */
  1237.     Xangle = 0;
  1238.     Yangle = 0;
  1239.     Zangle = 0;
  1240.     zoom = 1;
  1241.     
  1242.     /* check for icon */
  1243.     hasicon = true;
  1244.     if (N)
  1245.         {
  1246.         err = FSpGetFInfo (&myFSS, &fin);
  1247.         if (err) died ("Could not Get File Info", err, 305);
  1248.         if (fin.fdCreator != 'KrOt') hasicon = FALSE;
  1249.         updatemenus();
  1250.         }
  1251.     else doclose();
  1252.     
  1253.     /* draw the picture to GWorld and screen */
  1254.     if (N != 0) ShowWindow ((WindowPtr)thewindow);
  1255.     
  1256.     rotate ();
  1257.     InitCursor();
  1258.     
  1259.     if (PARS.INFO) info();
  1260. }
  1261.  
  1262. //************************************************************************
  1263.  
  1264. void startball (void)
  1265. {
  1266.     cn = 0;
  1267.     ct = TickCount();
  1268.     SetCursor (*(curshan[cn]));
  1269. }
  1270.  
  1271. //************************************************************************
  1272.  
  1273. void goball (void)
  1274. {
  1275.     if (TickCount() > (ct+1))
  1276.         {
  1277.         if (++cn >= 8) cn = 0;
  1278.         SetCursor (*(curshan[cn]));
  1279.         ct = TickCount();
  1280.         }
  1281. }
  1282.  
  1283. //************************************************************************
  1284.  
  1285. void installAEhandlers (void)
  1286. {
  1287.     /* install the required apple event handlers */
  1288.     AEEventHandlerUPP OPENae, QUITae, STARTae, PRINTae;
  1289.     
  1290.     // must use these for PPC proc pointers
  1291.     // also works for 68K if using Universal Headers
  1292.     OPENae = NewAEEventHandlerProc ((ProcPtr) &openAE);
  1293.     QUITae = NewAEEventHandlerProc ((ProcPtr) &quitAE);
  1294.     STARTae = NewAEEventHandlerProc ((ProcPtr) &startAE);
  1295.     PRINTae = NewAEEventHandlerProc ((ProcPtr) &printAE);
  1296.     
  1297.     err = AEInstallEventHandler (kCoreEventClass, kAEOpenDocuments,
  1298.         OPENae, 0, FALSE);
  1299.     if (err) died ("Error Installing OpenDoc Apple Event", err, 401);
  1300.     
  1301.     err = AEInstallEventHandler (kCoreEventClass, kAEQuitApplication,
  1302.         QUITae, 0, FALSE);
  1303.     if (err) died ("Error Installing QuitApp Apple Event", err, 402);
  1304.     
  1305.     err = AEInstallEventHandler (kCoreEventClass, kAEOpenApplication,
  1306.         STARTae, 0, FALSE);
  1307.     if (err) died ("Error Installing OpenApp Apple Event", err, 403);
  1308.     
  1309.     err = AEInstallEventHandler (kCoreEventClass, kAEPrintDocuments,
  1310.         PRINTae, 0, FALSE);
  1311.     if (err) died ("Error Installing PrintDoc Apple Event", err, 404);
  1312. }
  1313.  
  1314. //************************************************************************
  1315.  
  1316. void DoHighLevelEvent (EventRecord *theEvent)
  1317. {
  1318.     /* process high level events */
  1319.     err = AEProcessAppleEvent (theEvent);
  1320.     if (err) died ("Error Processing Apple Event", err, 405);
  1321. }
  1322.  
  1323. //************************************************************************
  1324.  
  1325. pascal    OSErr    openAE (AppleEvent *theEvent, AppleEvent *reply, long refcon)
  1326. {
  1327.     AEDescList    docList;
  1328.     long        n;
  1329.     AEKeyword    keywd;
  1330.     DescType    rtype;
  1331.     Size        acsize;
  1332.     FSSpec        myFSS;
  1333.     
  1334.     /* open document apple event */
  1335.     err = AEGetParamDesc (theEvent, keyDirectObject, typeAEList, &docList);
  1336.     if (err) died ("Error Processing Apple Event", err, 406);
  1337.     
  1338.     /* count number of document to be opened */
  1339.     err = AECountItems (&docList, &n);
  1340.     if (err) died ("Error Processing Apple Event", err, 407);
  1341.     if (n < 1) died ("No File for OpenDoc Apple Event", 0, 408);
  1342.     
  1343.     /* get FSS record of the first document only */
  1344.     err = AEGetNthPtr (&docList, 1, typeFSS, &keywd, &rtype,
  1345.         &myFSS, sizeof(myFSS), &acsize);
  1346.     if (err) died ("Error Processing Apple Event", err, 409);
  1347.     
  1348.     /* get rid of storage */
  1349.     err = AEDisposeDesc (&docList);
  1350.     if (err) died ("Error Processing Apple Event", err, 410);
  1351.     
  1352.     /* open the passed file */
  1353.     readfile (myFSS);
  1354.     
  1355.     return noErr;
  1356. }
  1357.  
  1358. //************************************************************************
  1359.  
  1360. pascal OSErr quitAE(AppleEvent *theEvent, AppleEvent *reply, long refcon)
  1361. {
  1362.     // quit apple event - set the done flag
  1363.     // CANNOT just ExitToShell() from here!!!
  1364.     done = true;
  1365.     return noErr;
  1366. }
  1367.  
  1368. //************************************************************************
  1369.  
  1370. pascal    OSErr    printAE (AppleEvent *theEvent, AppleEvent *reply, long refcon)
  1371. {
  1372.     /* print apple event not handled here */
  1373.     return errAEEventNotHandled;
  1374. }
  1375.  
  1376. //************************************************************************
  1377.  
  1378. pascal    OSErr    startAE (AppleEvent *theEvent, AppleEvent *reply, long refcon)
  1379. {
  1380.     /* startup apple event - ask for an input file */
  1381.     getuserfile();
  1382.     return noErr;
  1383. }
  1384.  
  1385. //************************************************************************
  1386.  
  1387. void info (void)
  1388. {
  1389.     GrafPtr        oldPort;
  1390.     Str255        tempStr;
  1391.     long    Theight, Twidth, i, h;
  1392.     
  1393.     Theight = 80 + comH*12;
  1394.     if (comn) Theight = Theight + 20;
  1395.     Twidth = comW*5 + 7;
  1396.     if (Twidth < 245) Twidth = 245;
  1397.     
  1398.     SizeWindow(infowindow, Twidth, Theight, TRUE);
  1399.     
  1400.     GetPort (&oldPort);
  1401.     SetPort (infowindow);
  1402.     EraseRect (&infowindow->portRect);
  1403.     
  1404.     // Main Headers
  1405.     TextFont (geneva);
  1406.     TextFace (bold);
  1407.     TextSize (9);
  1408.     MoveTo (4, 13);
  1409.     DrawString ("\pFile Name:");    
  1410.     MoveTo (4, 30);
  1411.     DrawString ("\pMemory Information");    
  1412.     MoveTo(4, 95);
  1413.     DrawString("\pFile Comments");    
  1414.     
  1415.     // File Name
  1416.     TextFace(0);
  1417.     GetWTitle((WindowPtr)thewindow, tempStr);
  1418.     MoveTo(65, 13);
  1419.     if (N > 0) DrawString (tempStr);
  1420.     else DrawString ("\p<none>");
  1421.         
  1422.     // Memory info
  1423.     MoveTo (7, 45);
  1424.     DrawString ("\pNumber of drawing commands in file:");    
  1425.     NumToString (N, tempStr);
  1426.     MoveTo (200, 45);
  1427.     DrawString (tempStr);
  1428.     MoveTo (7, 60);
  1429.     DrawString ("\pNumber of drawing commands allowed:");
  1430.     NumToString (MaxPoints, tempStr);
  1431.     MoveTo (200, 60);
  1432.     DrawString (tempStr);
  1433.     MoveTo (7, 75);
  1434.     DrawString ("\pNumber of bytes/additional command:");
  1435.     NumToString (Nspace, tempStr);
  1436.     MoveTo (200, 75);
  1437.     DrawString (tempStr);
  1438.     
  1439.     h = 108;
  1440.     MoveTo (7, h);
  1441.     for (i=0;i<comn;i++)
  1442.         {
  1443.         if (comments[i] == 13)
  1444.             {
  1445.             h = h + 12;
  1446.             MoveTo(7, h);
  1447.             }
  1448.         else
  1449.             {
  1450.             DrawChar (comments[i]);
  1451.             }
  1452.         }
  1453.     
  1454.     SetPort (oldPort);
  1455. }
  1456.  
  1457. //************************************************************************
  1458.  
  1459. void died (char desc[255], int code, int ref)
  1460. {
  1461.     /* nasty error has occurred - report it and quit */
  1462.     char a[50], b[50];
  1463.     
  1464.     CtoPstr (desc);
  1465.     NumToString (code, (StringPtr)a);
  1466.     NumToString (ref, (StringPtr)b);
  1467.     ParamText ((StringPtr)desc, (StringPtr)a, (StringPtr)b, NULL);
  1468.     Alert(129,NULL);
  1469.     ExitToShell();
  1470. }
  1471.  
  1472. //************************************************************************
  1473.  
  1474. void keyrotate (char ch, Boolean rep) // rep = repeat key
  1475. {
  1476.     KeyMap theKeys, theKeys1;
  1477.     Boolean validkey, stopit, slowly;
  1478.     long counting = 0;
  1479.     unsigned long tim, tim1;
  1480.     
  1481.     if (N)
  1482.         {
  1483.         stopit = FALSE;
  1484.         slowly = FALSE;
  1485.         validkey = TRUE;
  1486.         GetKeys (theKeys);
  1487.         GetKeys (theKeys1);
  1488.         
  1489.         do
  1490.             {
  1491.             tim = TickCount();
  1492.             switch (ch)
  1493.                 {
  1494.                 case 'm':
  1495.                     centerimage();
  1496.                 break;
  1497.                 
  1498.                 case 'M':
  1499.                     centerimage();
  1500.                 break;
  1501.                 
  1502.                 case 'x':
  1503.                     Xangle++;
  1504.                 break;
  1505.                 
  1506.                 case 'y':
  1507.                     Yangle++;
  1508.                 break;
  1509.                 
  1510.                 case 'z':
  1511.                     Zangle++;
  1512.                 break;
  1513.                 
  1514.                 case 'X':
  1515.                     Xangle--;
  1516.                 break;
  1517.                 
  1518.                 case 'Y':
  1519.                     Yangle--;
  1520.                 break;
  1521.                 
  1522.                 case 'Z':
  1523.                     Zangle--;
  1524.                 break;
  1525.                 
  1526.                 case 31: // down arrow
  1527.                     Xangle++;
  1528.                 break;
  1529.                 
  1530.                 case 30: // up arrow
  1531.                     Xangle--;
  1532.                 break;
  1533.                 
  1534.                 case 29: // right arrow
  1535.                     Zangle++;
  1536.                 break;
  1537.                 
  1538.                 case 28: // left arrow
  1539.                     Zangle--;
  1540.                 break;
  1541.                 
  1542.                 case '=':
  1543.                 case '+':
  1544.                     {
  1545.                     counting++;
  1546.                     zoom *= 1 + counting/100.0;
  1547.                     slowly = TRUE;
  1548.                     }
  1549.                 break;
  1550.                 
  1551.                 case '-':
  1552.                     {
  1553.                     counting++;
  1554.                     zoom /= 1 + counting/100.0;
  1555.                     slowly = TRUE;
  1556.                     }
  1557.                 break;
  1558.                 
  1559.                 case '3':
  1560.                     {
  1561.                     moveit(0.02);
  1562.                     slowly = TRUE;
  1563.                     }
  1564.                 break;
  1565.                 
  1566.                 case '1':
  1567.                     {
  1568.                     moveit(-0.02);
  1569.                     slowly = TRUE;
  1570.                     }
  1571.                 break;
  1572.                 
  1573.                 case '7': // decrease angle
  1574.                     if (PARS.STEREO)
  1575.                         {
  1576.                         PARS.STangle--;
  1577.                         if (PARS.STangle < 0)
  1578.                             {
  1579.                             SysBeep(1);
  1580.                             PARS.STangle = 0;
  1581.                             }
  1582.                         updatemenus();
  1583.                         slowly = TRUE;
  1584.                         }
  1585.                 break;
  1586.                 
  1587.                 case '9': // increase angle
  1588.                     if (PARS.STEREO)
  1589.                         {
  1590.                         PARS.STangle++;
  1591.                         if (PARS.STangle > 20)
  1592.                             {
  1593.                             SysBeep(1);
  1594.                             PARS.STangle = 20;
  1595.                             }
  1596.                         updatemenus();
  1597.                         slowly = TRUE;
  1598.                         }
  1599.                 break;
  1600.                 
  1601.                 case '4': // decrease sep
  1602.                     if (PARS.STEREO && PARS.KIND < 3)
  1603.                         {
  1604.                         PARS.STsep--;
  1605.                         if (PARS.STsep < -40)
  1606.                             {
  1607.                             SysBeep(1);
  1608.                             PARS.STsep = -40;
  1609.                             }
  1610.                         slowly = TRUE;
  1611.                         }
  1612.                 break;
  1613.                 
  1614.                 case '6': // increase sep
  1615.                     if (PARS.STEREO && PARS.KIND < 3)
  1616.                         {
  1617.                         PARS.STsep++;
  1618.                         if (PARS.STsep > 40)
  1619.                             {
  1620.                             SysBeep(1);
  1621.                             PARS.STsep = 40;
  1622.                             }
  1623.                         slowly = TRUE;
  1624.                         }
  1625.                 break;
  1626.                 
  1627.                 case 'H':
  1628.                 case 'h':
  1629.                     if (PARS.SHANGS) PARS.SHANGS = FALSE;
  1630.                     else PARS.SHANGS = TRUE;
  1631.                     updatemenus();
  1632.                     rotate();
  1633.                 break;
  1634.                 
  1635.                 default:
  1636.                     validkey = FALSE;
  1637.                 }
  1638.             if (validkey) rotate ();
  1639.             GetKeys (theKeys);
  1640.             if (theKeys[0] != theKeys1[0] || theKeys[1] != theKeys1[1] ||
  1641.                 theKeys[2] != theKeys1[2] || theKeys[3] != theKeys1[3] || !rep)
  1642.                 stopit = TRUE;
  1643.             if (!stopit && slowly)
  1644.                 do { tim1 = TickCount(); } while ((tim1-tim) < 4);
  1645.             }
  1646.         while (!stopit);
  1647.         }
  1648. }
  1649.  
  1650. //************************************************************************
  1651.  
  1652. void rotate (void) // rotate using Xangle, Yangle and Zangle and draw the result
  1653. {
  1654.     if (!PARS.FUNKY) // erase buffer
  1655.         {
  1656.         Byte *cbase; long i;
  1657.         for (i=0,cbase=base;i<Wheight;i++,cbase+=rb)
  1658.             if(PARS.WBACK) bzero(cbase, Wwidth);
  1659.             else memset(cbase,255, Wwidth);
  1660.         }
  1661.     
  1662.     if (PARS.STEREO)
  1663.         {
  1664.         if (PARS.KIND < 3) rotatestereo();
  1665.         else rotatestereoRB();
  1666.         }
  1667.     else rotatemono();
  1668.     
  1669.     if (PARS.SHANGS)
  1670.         {
  1671.         while (Xangle >= 360) Xangle -= 360;
  1672.         while (Yangle >= 360) Yangle -= 360;
  1673.         while (Zangle >= 360) Zangle -= 360;
  1674.         while (Xangle <= -360) Xangle += 360;
  1675.         while (Yangle <= -360) Yangle += 360;
  1676.         while (Zangle <= -360) Zangle += 360;
  1677.         showangles();
  1678.         }
  1679.     
  1680.     // reset rotation angles
  1681.     if (PARS.ROTYPE == 1)
  1682.         {
  1683.         Xangle = 0;
  1684.         Yangle = 0;
  1685.         Zangle = 0;
  1686.         }
  1687.     
  1688.     // show the result
  1689.     CopyBits((BitMapPtr)drawPixMapP, (BitMapPtr)windowPixMapP,
  1690.         &frameRect, &frameRect, srcCopy, nil);
  1691. }
  1692.  
  1693. //************************************************************************
  1694.  
  1695. void rotatestereo ()
  1696. {
  1697.     double  X, Y, Z, X3, Y3, Z3, X3b, Y3b, Z3b;
  1698.     double  CZ, SZ, CY, SY, CX, SX, CZb, SZb;
  1699.     double  AM, BM, CM, DM, EM, FM, GM, HM, IM;
  1700.     double  P, B, H, Bb;
  1701.     long    i, j, XX, YY, XX1=0, YY1=0, XXb, YYb, XX1b=0, YY1b=0;
  1702.     double  tempWidth, tempWidthb, tempHeight, tempZoom, tempPerspec;
  1703.     double  Ldep, Ldepb, dep1=0, dep2=0;
  1704.     long    LEc, Lddd, Ldddb, Lugh, Lugh1, Lughb, Lugh1b;
  1705.     long    currcolor, LWheight=Wheight, LWwidth=Wwidth, Lrb=rb,bigdots=PARS.BIGDOTS;
  1706.     Byte    bytecolor, bytecolorb;
  1707.     struct Aray *paaa;
  1708.     
  1709.     if ((PARS.KIND < 3 || !PARS.STEREO) && (PARS.HIDDEN || (PARS.BIGDOTS == 11 && gotdots)))
  1710.         bzero(plane, LWwidth*LWheight); //bzero courtesy of tim@apple.com (Tim Olson)
  1711.  
  1712.     P  = Xangle * DEGTORAD;
  1713.     H  = Yangle * DEGTORAD;
  1714.     B  = Zangle * DEGTORAD;
  1715.     Bb = PARS.STangle * DEGTORAD * 0.5;
  1716.     if (PARS.PARALLEL) Bb = -Bb;
  1717.  
  1718.     CX = cos(P);
  1719.     SX = sin(P);
  1720.     CY = cos(H);
  1721.     SY = sin(H);
  1722.     CZ = cos(B);
  1723.     SZ = sin(B);
  1724.     CZb= cos(Bb);
  1725.     SZb= sin(Bb);
  1726.     
  1727.     /* rotation matrix for x[y[z[rot]]] */
  1728.     AM =  CY*CZ;
  1729.     BM =  CY*SZ;
  1730.     CM =  -SY;
  1731.     DM =  SX*SY*CZ-CX*SZ;
  1732.     EM =  SX*SY*SZ+CX*CZ;
  1733.     FM =  SX*CY;
  1734.     GM =  CX*SY*CZ+SX*SZ;
  1735.     HM =  CX*SY*SZ-SX*CZ;
  1736.     IM =  CX*CY;
  1737.  
  1738.     if (PARS.COLOR) //setup so Lddd=dep*dep1+dep2
  1739.         {
  1740.         if (PARS.DEPTHcue)
  1741.             dep1=10.0;
  1742.         else
  1743.             dep2=9.0;
  1744.         }
  1745.     else
  1746.         {
  1747.         if (PARS.WBACK)
  1748.             dep2=11.0;
  1749.         else
  1750.             dep2=10.0;
  1751.         }
  1752.     
  1753.     tempZoom = (double)(W2middle)*zoom*.5;
  1754.     tempWidth = (double)(LWwidth)*(0.25 - (double)PARS.STsep*0.00625);
  1755.     tempWidthb = (double)(LWwidth)*(0.75 + (double)PARS.STsep*0.00625);
  1756.     tempHeight = (double)(LWheight)*.5;
  1757.     tempPerspec = ((double)PARS.PERSPEC*.07);
  1758.     
  1759.     for (LEc = 0; LEc < N; LEc++)
  1760.         {
  1761.         //rotate a point
  1762.         paaa=aaa+LEc;
  1763.         if (PARS.CHIR)
  1764.             {
  1765.             X = paaa->a[0];
  1766.             Y =-paaa->a[1];
  1767.             Z = paaa->a[2];
  1768.             X3 = AM * X + BM * Y + CM * Z;
  1769.             Y3 = DM * X + EM * Y + FM * Z;
  1770.             Z3 = GM * X + HM * Y + IM * Z;
  1771.             if (PARS.ROTYPE == 1)
  1772.                 {
  1773.                 paaa->a[0] = X3;
  1774.                 paaa->a[1] = -Y3;
  1775.                 paaa->a[2] = Z3;
  1776.                 }
  1777.             }
  1778.         else
  1779.             {
  1780.             X = paaa->a[0];
  1781.             Y = paaa->a[1];
  1782.             Z = paaa->a[2];
  1783.             X3 = AM * X + BM * Y + CM * Z;
  1784.             Y3 = DM * X + EM * Y + FM * Z;
  1785.             Z3 = GM * X + HM * Y + IM * Z;
  1786.             if (PARS.ROTYPE == 1)
  1787.                 {
  1788.                 paaa->a[0] = X3;
  1789.                 paaa->a[1] = Y3;
  1790.                 paaa->a[2] = Z3;
  1791.                 }
  1792.             }
  1793.         X3b = CZb * X3 + SZb * Y3;
  1794.         Y3b = -SZb * X3 + CZb * Y3;
  1795.         Z3b = Z3;
  1796.         
  1797.         /* calculate depth of point */
  1798.         Ldep = Y3*0.5+0.5;
  1799.         Ldepb   = Y3b*0.5+0.5;
  1800.         Lugh    = Ldep * 255.0;
  1801.         Lughb   = Ldepb* 255.0;
  1802.         currcolor=cc[LEc];
  1803.         Lddd    = dep1*Ldep+dep2;
  1804.         Ldddb   = dep1*Ldepb+dep2;
  1805.         
  1806.         // take perspective into account
  1807.         Y3 = 1.0 - tempPerspec*(1.0 - Ldep);
  1808.         Y3b = 1.0 - tempPerspec*(1.0 - Ldepb);
  1809.         X3 *= Y3;     X3b *= Y3b;
  1810.         Z3 *= Y3;     Z3b *= Y3b;
  1811.         
  1812.         // 3D -> 2D
  1813.         XX  = tempWidth  + X3*tempZoom;
  1814.         YY  = tempHeight - Z3*tempZoom;
  1815.         XXb = tempWidthb + X3b*tempZoom;
  1816.         YYb = tempHeight - Z3b*tempZoom;
  1817.         
  1818.         if (currcolor < 0) // a point
  1819.             {
  1820.             currcolor = -currcolor;
  1821.             bytecolor = bcol [currcolor] [Lddd];
  1822.             bytecolorb = bcol [currcolor] [Ldddb];
  1823.             switch (bigdots)
  1824.                 {
  1825.                 case 11: //ball
  1826.                     {
  1827.                     cooldot (XX, YY, currcolor, Ldep, Lugh);
  1828.                     cooldot (XXb, YYb, currcolor, Ldepb, Lughb);
  1829.                     }
  1830.                     break;
  1831.                 
  1832.                 case 1: //dot size =1
  1833.                     {
  1834.                     if (XX < LWwidth && XX >= 0 && YY < LWheight && YY >= 0)
  1835.                         {
  1836.                         if (PARS.HIDDEN)
  1837.                             {
  1838.                             if (Lugh >= *(plane + LWwidth*YY + XX))
  1839.                                 {
  1840.                                 *(plane + LWwidth*YY + XX) = Lugh;
  1841.                                 base[Lrb*YY + XX] = bytecolor;
  1842.                                 }
  1843.                             }
  1844.                         else base[Lrb*YY + XX] = bytecolor;
  1845.                         }
  1846.                     
  1847.                     if (XXb < LWwidth && XXb >= 0 && YYb < LWheight && YYb >= 0)
  1848.                         {
  1849.                         if (PARS.HIDDEN)
  1850.                             {
  1851.                             if (Lughb >= *(plane + LWwidth*YYb + XXb))
  1852.                                 {
  1853.                                 *(plane + LWwidth*YYb + XXb) = Lughb;
  1854.                                 base[Lrb*YYb + XXb] = bytecolorb;
  1855.                                 }
  1856.                             }
  1857.                         else base[Lrb*YYb + XXb] = bytecolorb;
  1858.                         }
  1859.                     }
  1860.                     break;
  1861.                 
  1862.                 default: //PARS.BIGDOTS >1
  1863.                     {
  1864.                     XX -= (bigdots >> 1);
  1865.                     YY -= (bigdots >> 1);
  1866.                     XXb-= (bigdots >> 1);
  1867.                     YYb-= (bigdots >> 1);
  1868.                     if (PARS.HIDDEN)
  1869.                         {
  1870.                         for (j=0;j<bigdots;j++,YY++,YYb++)
  1871.                             for (i=0;i<bigdots;i++)
  1872.                                 {
  1873.                                 if (YY < LWheight && YY >= 0 && XX+i < LWwidth && XX+i >= 0)
  1874.                                     if (Lugh >= *(plane + LWwidth*YY + XX+i))
  1875.                                         {
  1876.                                         *(plane + LWwidth*YY + XX+i) = Lugh;
  1877.                                         base[Lrb*YY + XX+i] = bytecolor;
  1878.                                         }
  1879.                                 if (YYb < LWheight && YYb >= 0 && XXb+i < LWwidth && XXb+i >= 0)
  1880.                                     if (Lughb >= *(plane + LWwidth*YYb + XXb+i))
  1881.                                         {
  1882.                                         *(plane + LWwidth*YYb + XXb+i) = Lughb;
  1883.                                         base[Lrb*YYb + XXb+i] = bytecolorb;
  1884.                                         }
  1885.                                 }
  1886.                         }
  1887.                     else // not hidden
  1888.                         for (j=0;j<bigdots;j++,YY++,YYb++)
  1889.                             for (i=0;i<bigdots;i++)
  1890.                                 {
  1891.                                 if(YY < LWheight && YY >= 0 && XX+i < LWwidth && XX+i >= 0)
  1892.                                     base[Lrb*YY + XX+i] = bytecolor;
  1893.                                 if(YYb < LWheight && YYb >= 0 && XXb+i < LWwidth && XXb+i >= 0)
  1894.                                     base[Lrb*YYb + XXb+i] = bytecolorb;
  1895.                                 }
  1896.                     } //end default
  1897.                 } //end switch
  1898.             } //end a point
  1899.         else
  1900.             {
  1901.             if (currcolor) // a line
  1902.                 {
  1903.                 if (PARS.HIDDEN)
  1904.                     {
  1905.                     plot_hiddenline (XX, XX1, YY, YY1, bcol[currcolor][Lddd], Lugh, Lugh1);
  1906.                     plot_hiddenline (XXb, XX1b, YYb, YY1b, bcol[currcolor][Ldddb], Lughb, Lugh1b);
  1907.                     }
  1908.                 else
  1909.                     {
  1910.                     plotline (XX, XX1, YY, YY1, bcol[currcolor][Lddd]);
  1911.                     plotline (XXb, XX1b, YYb, YY1b, bcol[currcolor][Ldddb]);
  1912.                     }
  1913.                 }
  1914.             XX1 = XX;  XX1b = XXb; // move
  1915.             YY1 = YY;  YY1b = YYb;
  1916.             Lugh1= Lugh; Lugh1b= Lughb;
  1917.             }
  1918.         }
  1919. }
  1920.  
  1921. //************************************************************************
  1922.  
  1923. void rotatemono (void)
  1924. {
  1925.     double     X, Y, Z, X3, Y3, Z3;
  1926.     double    CZ, SZ, CY, SY, CX, SX;
  1927.     double    AM, BM, CM, DM, EM, FM, GM, HM, IM;
  1928.     double    P, B, H;
  1929.     long i, j;
  1930.     double  tempWidth, tempHeight, tempZoom, tempPerspec;
  1931.     double  Ldep, dep1=0, dep2=0;
  1932.     long    LEc, Lugh, Lugh1, Lddd, currcolor, LWheight=Wheight, LWwidth=Wwidth, Lrb=rb;
  1933.     long        XX, XX1, YY, YY1;
  1934.     long    bigdots=PARS.BIGDOTS;
  1935.     Byte        bytecolor;
  1936.     struct Aray *paaa;
  1937.     Byte *cbase, *cplane;
  1938.     
  1939.     //set up locals
  1940.     tempZoom    =(double)(Wmiddle)*zoom*.5;
  1941.     tempWidth    =(double)(LWwidth)*.5;
  1942.     tempHeight    =(double)(LWheight)*.5;
  1943.     tempPerspec    =((double)PARS.PERSPEC*.07);
  1944.     
  1945.     if (PARS.COLOR) //setup so Lddd=dep*dep1+dep2
  1946.         {
  1947.         if (PARS.DEPTHcue)
  1948.             dep1=10.0;
  1949.         else
  1950.             dep2=9.0;
  1951.         }
  1952.     else
  1953.         {
  1954.         if (PARS.WBACK)
  1955.             dep2=11.0;
  1956.         else
  1957.             dep2=10.0;
  1958.         }
  1959.  
  1960.     if ((PARS.KIND < 3 || !PARS.STEREO) && (PARS.HIDDEN || (PARS.BIGDOTS == 11 && gotdots)))
  1961.         bzero(plane, LWwidth*LWheight);
  1962.         
  1963.     P  = DEGTORAD * Xangle;
  1964.     H  = DEGTORAD * Yangle;
  1965.     B  = DEGTORAD * Zangle;
  1966.     
  1967.     CX = cos(P);
  1968.     SX = sin(P);
  1969.     CY = cos(H);
  1970.     SY = sin(H);
  1971.     CZ = cos(B);
  1972.     SZ = sin(B);
  1973.     
  1974.     /* rotation matrix for x[y[z[rot]]] */
  1975.     AM =  CY*CZ;
  1976.     BM =  CY*SZ;
  1977.     CM =  -SY;
  1978.     DM =  SX*SY*CZ-CX*SZ;
  1979.     EM =  SX*SY*SZ+CX*CZ;
  1980.     FM =  SX*CY;
  1981.     GM =  CX*SY*CZ+SX*SZ;
  1982.     HM =  CX*SY*SZ-SX*CZ;
  1983.     IM =  CX*CY;
  1984.     
  1985.     for (LEc = 0; LEc < N; LEc++)
  1986.         {
  1987.         //rotate a point
  1988.         paaa=aaa+LEc;
  1989.         if (PARS.CHIR)
  1990.             {
  1991.             X = paaa->a[0];
  1992.             Y =-paaa->a[1];
  1993.             Z = paaa->a[2];
  1994.             X3 = AM * X + BM * Y + CM * Z;
  1995.             Y3 = DM * X + EM * Y + FM * Z;
  1996.             Z3 = GM * X + HM * Y + IM * Z;
  1997.             if (PARS.ROTYPE == 1)
  1998.                 {
  1999.                 paaa->a[0] = X3;
  2000.                 paaa->a[1] = -Y3;
  2001.                 paaa->a[2] = Z3;
  2002.                 }
  2003.             }
  2004.         else
  2005.             {
  2006.             X = paaa->a[0];
  2007.             Y = paaa->a[1];
  2008.             Z = paaa->a[2];
  2009.             X3 = AM * X + BM * Y + CM * Z;
  2010.             Y3 = DM * X + EM * Y + FM * Z;
  2011.             Z3 = GM * X + HM * Y + IM * Z;
  2012.             if (PARS.ROTYPE == 1)
  2013.                 {
  2014.                 paaa->a[0] = X3;
  2015.                 paaa->a[1] = Y3;
  2016.                 paaa->a[2] = Z3;
  2017.                 }
  2018.             }
  2019.         
  2020.         /* calculate depth of point */
  2021.         Ldep = Y3*0.5+0.5;
  2022.         Lugh = Ldep * 255.0;
  2023.         currcolor=cc[LEc];
  2024.         Lddd=dep1*Ldep+dep2;
  2025.         
  2026.         // take perspective into account
  2027.         Y3=1.0 - tempPerspec*(1.0 - Ldep);
  2028.         X3 *= Y3;
  2029.         Z3 *= Y3;
  2030.         
  2031.         // 3D -> 2D
  2032.         XX = tempWidth  + X3*tempZoom;
  2033.         YY = tempHeight - Z3*tempZoom;
  2034.         
  2035.         if (currcolor < 0) // a point
  2036.             {
  2037.             currcolor=-currcolor;
  2038.             bytecolor = bcol[currcolor][Lddd];
  2039.             switch (bigdots)
  2040.                 {
  2041.                 case 11: //ball
  2042.                     cooldot (XX, YY, currcolor, Ldep, Lugh);
  2043.                     break;
  2044.                 
  2045.                 case 1: //dot size =1
  2046.                     {
  2047.                     if (XX < LWwidth && XX >= 0 && YY < LWheight && YY >= 0)
  2048.                         {
  2049.                         if (PARS.HIDDEN)
  2050.                             {
  2051.                             if (Lugh >= *(plane + LWwidth*YY + XX))
  2052.                                 {
  2053.                                 *(plane + LWwidth*YY + XX) = Lugh;
  2054.                                 base[Lrb*YY + XX] = bytecolor;
  2055.                                 }
  2056.                             }
  2057.                         else base[Lrb*YY + XX] = bytecolor;
  2058.                         }
  2059.                     }
  2060.                     break;
  2061.                 
  2062.                 default: //PARS.BIGDOTS >1
  2063.                     {
  2064.                     XX -= (bigdots >> 1);
  2065.                     YY -= (bigdots >> 1);
  2066.                     if (PARS.HIDDEN)
  2067.                         {
  2068.                         for (j=0;j<bigdots;j++,YY++) if(YY < LWheight && YY >= 0)
  2069.                             for (cplane=plane+LWwidth*YY+XX,i=0;i<bigdots;i++)
  2070.                                     if (XX+i < LWwidth && XX+i >= 0 && Lugh >= cplane[i])
  2071.                                         {
  2072.                                         cplane[i] = Lugh;
  2073.                                         base[Lrb*YY + XX+i] = bytecolor;
  2074.                                         }
  2075.                         }
  2076.                     else
  2077.  
  2078.                         for (j=0;j<bigdots;j++,YY++) if(YY < LWheight && YY >= 0)
  2079.                             for (cbase=base+Lrb*YY+XX,i=0;i<bigdots;i++) if (XX+i < LWwidth && XX+i >= 0)
  2080.                                 cbase[i] = bytecolor;
  2081.                     } //end bigdots
  2082.                 } //end switch
  2083.             } //end a point
  2084.         else
  2085.             {
  2086.             if (currcolor) // a line
  2087.                 {
  2088.                 if (PARS.HIDDEN)
  2089.                     plot_hiddenline (XX, XX1, YY, YY1, bcol[currcolor][Lddd], Lugh, Lugh1);
  2090.                 else
  2091.                     plotline (XX, XX1, YY, YY1, bcol[currcolor][Lddd]);
  2092.                 }
  2093.             XX1 = XX; // move
  2094.             YY1 = YY;
  2095.             Lugh1 = Lugh;
  2096.             }
  2097.         }
  2098. }
  2099.  
  2100. //************************************************************************
  2101.  
  2102. void adjustsize (void)
  2103. {
  2104.     Point p;
  2105.     GrafPtr oldPort;
  2106.     
  2107.     HLockHi((Handle)windowPixMapH);
  2108.     LockPixels(windowPixMapH);
  2109.     windowPixMapP = *thewindow->portPixMap;
  2110.     
  2111.     /* get window width and height */
  2112.     p.h = (thewindow->portRect).left;
  2113.     p.v = (thewindow->portRect).top;
  2114.     LocalToGlobal (&p);
  2115.     PARS.WINleft = p.h;
  2116.     PARS.WINtop = p.v;
  2117.     p.h = (thewindow->portRect).right;
  2118.     p.v = (thewindow->portRect).bottom;
  2119.     LocalToGlobal (&p);
  2120.     PARS.WINright = p.h;
  2121.     PARS.WINbottom = p.v;
  2122.     
  2123.     Wwidth = (thewindow->portRect).right - (thewindow->portRect).left;
  2124.     Wheight = (thewindow->portRect).bottom - (thewindow->portRect).top;
  2125.     
  2126.     // get floating window position
  2127.     GetPort (&oldPort);
  2128.     SetPort (infowindow);
  2129.     p.h = (infowindow->portRect).left;
  2130.     p.v = (infowindow->portRect).top;
  2131.     LocalToGlobal (&p);
  2132.     PARS.INFOleft = p.h;
  2133.     PARS.INFOtop = p.v;
  2134.     SetPort (oldPort);
  2135.     
  2136.     /* size of square image */
  2137.     if (Wheight < Wwidth) Wmiddle = Wheight;
  2138.     else Wmiddle = Wwidth;
  2139.     
  2140.     /* size of stereo image */
  2141.     if (Wheight < Wwidth/2) W2middle = Wheight;
  2142.     else W2middle = Wwidth/2;
  2143.     
  2144.     /* set active rectangle dimensions */
  2145.     SetRect (&frameRect, 0, 0, Wwidth+1, Wheight+1);
  2146.     ClipRect(&frameRect);
  2147. }
  2148.  
  2149. //************************************************************************
  2150.  
  2151. void plotline (long x, long x1, long y, long y1, long bytecol) // Custom Line drawing routine for extra speed
  2152. {
  2153.     long i, k;
  2154.     long LWwidth=Wwidth,LWheight=Wheight,Lrb=rb,line=PARS.LINE,halfline=(line>>1);
  2155.     int r, dx, dy;
  2156.     Byte *cbase;
  2157.     
  2158.     // make x <= x1
  2159.     if (x > x1) { i = x1; x1 = x; x = i; i = y1; y1 = y; y = i; }
  2160.     
  2161.     dx = (x1-x)*2; dy = (y1-y)*2; // << 1
  2162.     
  2163.     if (dy >= 0) //positive line
  2164.         {
  2165.         if (dx > dy) // x longer
  2166.             {
  2167.             if(x1>=LWwidth-1) x1=LWwidth-1;
  2168.             r = dy - (dx>>1); dx -= dy;
  2169.             for (;x<=x1;x++)
  2170.                 {
  2171.                 if (x >= 0)
  2172.                     {
  2173.                     i = y - halfline; k = i + line;
  2174.                     if(i<0) i=0;
  2175.                     if(k>LWheight) k=LWheight;
  2176.                     for(cbase=base+Lrb*i + x;i<k;i++,cbase+=Lrb) *cbase = bytecol;
  2177.                     }
  2178.                 if (r >= 0) { y++; r -= dx; }
  2179.                 else r += dy;
  2180.                 }
  2181.             }
  2182.         else // y longer
  2183.             {
  2184.             if(y1>=LWheight-1) y1=LWheight-1;
  2185.             r = dx - (dy>>1); dy -= dx;
  2186.             for (;y<=y1;y++)
  2187.                 {
  2188.                 if (y >= 0)
  2189.                     {
  2190.                     i = x - halfline; k = i + line;
  2191.                     if(i<0) i=0;
  2192.                     if(k>LWwidth) k=LWwidth;
  2193.                     for(cbase=base+Lrb*y;i<k;i++) cbase[i] = bytecol;
  2194.                     }
  2195.                 if (r >= 0) { x++; r -= dy; }
  2196.                 else r += dx;
  2197.                 }
  2198.             }
  2199.         }
  2200.     else //negative line
  2201.         {
  2202.         dy=-dy;
  2203.         if (dx > dy) // x longer
  2204.             {
  2205.             if(x1>=LWwidth-1) x1=LWwidth-1;
  2206.             r = dy - (dx>>1); dx -= dy;
  2207.             for (;x<=x1;x++)
  2208.                 {
  2209.                 if (x >= 0)
  2210.                     {
  2211.                     i = y - halfline; k = i + line;
  2212.                     if(i<0) i=0;
  2213.                     if(k>LWheight) k=LWheight;
  2214.                     for(cbase=base+Lrb*i + x;i<k;i++,cbase+=Lrb) *cbase = bytecol;
  2215.                     }
  2216.                 if (r >= 0) { y--; r -= dx; }
  2217.                 else r += dy;
  2218.                 }
  2219.             }
  2220.         else // y longer
  2221.             {
  2222.             if(y>=LWheight-1) y=LWheight-1;
  2223.             r = dx - (dy>>1); dy -= dx;
  2224.             for (;y1<=y;y1++)
  2225.                 {
  2226.                 if (y1 >= 0)
  2227.                     {
  2228.                     i = x1 - halfline; k = i + line;
  2229.                     if(i<0) i=0;
  2230.                     if(k>LWwidth) k=LWwidth;
  2231.                     for(cbase=base+Lrb*y1;i<k;i++) cbase[i] = bytecol;
  2232.                     }
  2233.                 if (r >= 0) { x1--; r -= dy; }
  2234.                 else r += dx;
  2235.                 }
  2236.             }
  2237.         }
  2238. }
  2239.  
  2240. //************************************************************************
  2241.  
  2242. void plot_hiddenline (long x, long x1, long y, long y1, long bytecol, long ughx, long ugh1x) // Custom Line drawing routine for extra speed
  2243. {
  2244.     long xi, yi, ui, i, k;
  2245.     long LWwidth=Wwidth,LWheight=Wheight,Lrb=rb;
  2246.     long ughy,ddx,ddy,line=PARS.LINE,halfline=(line>>1);
  2247.     int r, dx, dy;
  2248.     Byte *cplane;
  2249.     
  2250.     // make x <= x1
  2251.     if (x > x1)
  2252.     {
  2253.      xi = x1; x1 = x; x = xi;
  2254.      yi = y1; y1 = y; y = yi;
  2255.      ui = ughx; ughx = ugh1x; ugh1x = ughx-ugh1x;
  2256.     }
  2257.     else ugh1x -= ughx;
  2258.     
  2259.     ddx=x1-x; ddy=y1-y;
  2260.     dx = ddx*2; dy = ddy*2; // << 1
  2261.     
  2262.     if (dy >= 0) //positive line
  2263.         {
  2264.         if (dx > dy) // x longer
  2265.             {
  2266.             if(x1>=LWwidth-1) x1=LWwidth-1;
  2267.             r = dy - ddx; dx -= dy; if (!ddx) ughy = ughx;
  2268.             for (xi=0;x<=x1;x++,xi+=ugh1x)
  2269.                 {
  2270.                 if (x >= 0)
  2271.                     {
  2272.                     i = y - halfline; k = i + line;
  2273.                     if(i<0) i=0;
  2274.                     if(k>LWheight) k=LWheight;
  2275.                     if (ddx) ughy = xi/ddx + ughx;
  2276.                     for(cplane=plane+x+LWwidth*i;i<k;i++,cplane+=LWwidth) if(ughy>=*cplane)
  2277.                     { *cplane = ughy; *(base + x+Lrb*i) = bytecol; }
  2278.                     }
  2279.                 if (r >= 0) { y++; r -= dx; }
  2280.                 else r += dy;
  2281.                 }
  2282.             }
  2283.         else // y longer
  2284.             {
  2285.             if(y1>=LWheight-1) y1=LWheight-1;
  2286.             r = dx - ddy; dy -= dx; if (!ddy) ughy = ughx;
  2287.             for (yi=0;y<=y1;y++,yi+=ugh1x)
  2288.                 {
  2289.                 if (y >= 0)
  2290.                     {
  2291.                     i = x - halfline; k = i + line;
  2292.                     if(i<0) i=0;
  2293.                     if(k>LWwidth) k=LWwidth;
  2294.                     if (ddy) ughy = yi/ddy + ughx;
  2295.                     for(cplane=plane+LWwidth*y;i<k;i++) if(ughy>=cplane[i])
  2296.                     { cplane[i] = ughy; *(base+Lrb*y + i) = bytecol; }
  2297.                     }
  2298.                 if (r >= 0) { x++; r -= dy; }
  2299.                 else r += dx;
  2300.                 }
  2301.             }
  2302.         }
  2303.     else //negative line
  2304.         {
  2305.         dy=-dy;
  2306.         if (dx > dy) // x longer
  2307.             {
  2308.             if(x1>=LWwidth-1) x1=LWwidth-1;
  2309.             r = dy - ddx; dx -= dy; if (!ddx) ughy = ughx;
  2310.             for (xi=0;x<=x1;x++,xi+=ugh1x)
  2311.                 {
  2312.                 if (x >= 0)
  2313.                     {
  2314.                     i = y - halfline; k = i + line;
  2315.                     if(i<0) i=0;
  2316.                     if(k>LWheight) k=LWheight;
  2317.                     if (ddx) ughy = xi/ddx + ughx;
  2318.                     for(cplane=plane+x+LWwidth*i;i<k;i++,cplane+=LWwidth) if(ughy>=*cplane)
  2319.                     { *cplane = ughy; *(base + x+Lrb*i) = bytecol; }
  2320.                     }
  2321.                 if (r >= 0) { y--; r -= dx; }
  2322.                 else r += dy;
  2323.                 }
  2324.             }
  2325.         else // y longer
  2326.             {
  2327.             //ddy = -ddy;
  2328.             if(y>=LWheight-1) y=LWheight-1;
  2329.             r = dx + ddy; dy -= dx; if (!ddy) ughy = ughx;
  2330.             for (yi=ddy*ugh1x;y1<=y;y1++,yi+=ugh1x)
  2331.                 {
  2332.                 if (y1 >= 0)
  2333.                     {
  2334.                     i = x1 - halfline; k = i + line;
  2335.                     if(i<0) i=0;
  2336.                     if(k>LWwidth) k=LWwidth;
  2337.                     if (ddy) ughy = yi/ddy + ughx;
  2338.                     for(cplane=plane+LWwidth*y1;i<k;i++) if(ughy>=cplane[i])
  2339.                     { cplane[i] = ughy; *(base + i + Lrb*y1) = bytecol; }
  2340.                     }
  2341.                 if (r >= 0) { x1--; r -= dy; }
  2342.                 else r += dx;
  2343.                 }
  2344.             }
  2345.         }
  2346. }
  2347.  
  2348. //************************************************************************
  2349.  
  2350. void doclose(void) // close window
  2351. {
  2352.     N = 0;
  2353.     comn = 0;
  2354.     comW = 0;
  2355.     comH = 0;
  2356.     HideWindow ((WindowPtr)thewindow);
  2357.     if (PARS.INFO) info();
  2358.     updatemenus();
  2359. }
  2360.  
  2361. //************************************************************************
  2362.  
  2363. void resetimage (void)
  2364. {
  2365.     zoom = 1;
  2366.     
  2367.     PARS.STEREO = FALSE;
  2368.     PARS.PERSPEC = 3;
  2369.     PARS.STangle = 6;
  2370.     PARS.STsep = 0;
  2371.     PARS.DEPTHcue = TRUE;
  2372.     PARS.COLOR = TRUE;
  2373.     PARS.WBACK = FALSE;
  2374.     PARS.BIGDOTS = 1; //small dots
  2375.     PARS.CHIR = TRUE;
  2376.     PARS.PARALLEL = FALSE;
  2377.     PARS.dpi = 300;
  2378.     PARS.KIND = 1;
  2379.     PARS.GRAB = TRUE; // grab and spin on
  2380.     PARS.LINE = 1; // line width of 1
  2381.     PARS.HIDDEN = TRUE; // hide lines
  2382.     PARS.INFO = TRUE; // show info window
  2383.     PARS.FUNKY = FALSE; // no wierd traces
  2384.     PARS.ROTYPE = 1; // trackball rotation
  2385.     PARS.SHANGS = FALSE; // dont show angles
  2386.     
  2387.     UnlockPixels(windowPixMapH);
  2388.     MoveWindow ((WindowPtr)infowindow, 220, 50, TRUE);
  2389.     MoveWindow ((WindowPtr)thewindow, 10, 50, TRUE);
  2390.     if (MAXheight < 199 || MAXwidth < 199)
  2391.         SizeWindow ((WindowPtr)thewindow, MAXwidth-1, MAXheight-1, TRUE);
  2392.     else
  2393.         SizeWindow ((WindowPtr)thewindow, 199, 199, TRUE);
  2394.     if (PARS.INFO)
  2395.         {
  2396.         ShowWindow (infowindow);
  2397.         BringToFront (infowindow); //!!
  2398.         HiliteWindow (infowindow, TRUE); //!!
  2399.         }
  2400.     else HideWindow (infowindow);
  2401.     adjustsize();
  2402.     updatemenus();
  2403.     rotate();
  2404. }
  2405.  
  2406. //************************************************************************
  2407.  
  2408. void copyimage (void) // copy image to clipboard
  2409. {
  2410.     OpenCPicParams picheader;
  2411.     
  2412.     picheader.srcRect = frameRect;
  2413.     picheader.hRes = 72 << 16;
  2414.     picheader.vRes = 72 << 16;
  2415.     picheader.version = -2;
  2416.     picheader.reserved1 = 0;
  2417.     picheader.reserved2 = 0;
  2418.     
  2419.     thepic = OpenCPicture (&picheader);
  2420.     
  2421.     CopyBits((BitMapPtr)drawPixMapP, (BitMapPtr)windowPixMapP,
  2422.         &frameRect, &frameRect, srcCopy, nil);
  2423.     
  2424.     ClosePicture();
  2425.     
  2426.     err = ZeroScrap();
  2427.     if (err) died ("Error Clearing Clipboard", err, 501);
  2428.     
  2429.     HLock ((Handle)(thepic));
  2430.     err = PutScrap (GetHandleSize((Handle)thepic), 'PICT', (Ptr)*thepic);
  2431.     HUnlock ((Handle)(thepic));
  2432.     KillPicture (thepic);
  2433.  
  2434.     if (err) Alert(136,NULL);
  2435. }
  2436.  
  2437. //************************************************************************
  2438.  
  2439. void vectorcopy (void) // Quickdraw stuff only - no custom fast things
  2440. {
  2441.     long mem, Ec;
  2442.     double     X, Y, Z, X3, Y3, Z3;
  2443.     double    CZ, SZ, CY, SY, CX, SX;
  2444.     double    AM, BM, CM, DM, EM, FM, GM, HM, IM;
  2445.     double    dep;
  2446.     double    B;
  2447.     long XX, YY, XX1=0, YY1=0;
  2448.     
  2449.     startball();
  2450.     
  2451.     if (!PARS.WBACK) PaintRect(&frameRectDPI);
  2452.     
  2453.     if (!PARS.STEREO)
  2454.         {
  2455.         for (Ec = 0; Ec < N; Ec++)
  2456.             {
  2457.             goball();
  2458.             X = aaa[Ec].a[0];
  2459.             Y = aaa[Ec].a[1];
  2460.             Z = aaa[Ec].a[2];
  2461.             
  2462.             if (PARS.CHIR) Y = -Y;
  2463.             
  2464.             /* rotate the point */
  2465.             X3 = X;
  2466.             Y3 = Y;
  2467.             Z3 = Z;
  2468.             
  2469.             /* calculate depth of point */
  2470.             dep = (Y3 + 1)/2;
  2471.             
  2472.             if (PARS.PERSPEC) /* perspective is on*/
  2473.                 {
  2474.                 X3 = X3 * (1.0 - 7.0*PARS.PERSPEC/100.0 + 7.0*PARS.PERSPEC*dep/100.0);
  2475.                 Z3 = Z3 * (1.0 - 7.0*PARS.PERSPEC/100.0 + 7.0*PARS.PERSPEC*dep/100.0);
  2476.                 }
  2477.             
  2478.             XX = Wwidth*PARS.dpi/144 + Wmiddle*X3*zoom*PARS.dpi/144;
  2479.             YY = Wheight*PARS.dpi/144 - Wmiddle*Z3*zoom*PARS.dpi/144;
  2480.     
  2481.             if (cc[Ec] < 0) // a point
  2482.                 {
  2483.                 if (PARS.COLOR)
  2484.                     if (PARS.DEPTHcue) ddd = dep*10;
  2485.                     else ddd = 9;
  2486.                 else
  2487.                     {
  2488.                     if (PARS.WBACK) ddd = 11;
  2489.                     else ddd = 10;
  2490.                     }
  2491.                 //SetCPixel(XX, YY, &vcol[-cc[Ec]][ddd]);
  2492.                 MoveTo (XX,YY);
  2493.                 RGBForeColor(&vcol[-cc[Ec]][ddd]);
  2494.                 LineTo (XX, YY);                
  2495.                 }
  2496.             else if (cc[Ec] == 0) // move
  2497.                 {
  2498.                 MoveTo (XX, YY);
  2499.                 }
  2500.             else // a line
  2501.                 {
  2502.                 if (PARS.COLOR)
  2503.                     if (PARS.DEPTHcue) ddd = dep*10;
  2504.                     else ddd = 9;
  2505.                 else
  2506.                     {
  2507.                     if (PARS.WBACK) ddd = 11;
  2508.                     else ddd = 10;
  2509.                     }
  2510.                 RGBForeColor(&vcol[cc[Ec]][ddd]);
  2511.                 LineTo (XX, YY);
  2512.                 }
  2513.             mem = FreeMem ();
  2514.             if (mem < 20000)
  2515.                 {
  2516.                 ClosePicture();
  2517.                 KillPicture (thepic);
  2518.                 died ("Ran out of memory", Ec, 601);
  2519.                 }
  2520.             }
  2521.         }
  2522.     else //stereo
  2523.         {
  2524.         for (Ec = 0; Ec < N; Ec++)
  2525.             {
  2526.             goball();
  2527.             X = aaa[Ec].a[0];
  2528.             Y = aaa[Ec].a[1];
  2529.             Z = aaa[Ec].a[2];
  2530.             
  2531.             if (PARS.CHIR) Y = -Y;
  2532.             
  2533.             /* rotate the point */
  2534.             X3 = X;
  2535.             Y3 = Y;
  2536.             Z3 = Z;
  2537.             
  2538.             /* calculate depth of point */
  2539.             dep = (Y3 + 1)/2;
  2540.             
  2541.             if (PARS.PERSPEC) /* perspective is on*/
  2542.                 {
  2543.                 X3 = X3 * (1.0 - 7.0*PARS.PERSPEC/100.0 + 7.0*PARS.PERSPEC*dep/100.0);
  2544.                 Z3 = Z3 * (1.0 - 7.0*PARS.PERSPEC/100.0 + 7.0*PARS.PERSPEC*dep/100.0);
  2545.                 }
  2546.             
  2547.             XX = Wwidth*PARS.dpi/288 + W2middle*X3*zoom*PARS.dpi/144 -
  2548.                 PARS.STsep*Wwidth*PARS.dpi/11520;
  2549.             YY = Wheight*PARS.dpi/144 - W2middle*Z3*zoom*PARS.dpi/144;
  2550.     
  2551.             if (cc[Ec] < 0) // a point
  2552.                 {
  2553.                 if (PARS.COLOR)
  2554.                     if (PARS.DEPTHcue) ddd = dep*10;
  2555.                     else ddd = 9;
  2556.                 else
  2557.                     {
  2558.                     if (PARS.WBACK) ddd = 11;
  2559.                     else ddd = 10;
  2560.                     }
  2561.                 SetCPixel( XX, YY, &vcol[-cc[Ec]][ddd]);
  2562.                 }
  2563.             else if (cc[Ec] == 0) // move
  2564.                 {
  2565.                 MoveTo (XX, YY);
  2566.                 }
  2567.             else // a line
  2568.                 {
  2569.                 if (PARS.COLOR)
  2570.                     if (PARS.DEPTHcue) ddd = dep*10;
  2571.                     else ddd = 9;
  2572.                 else
  2573.                     {
  2574.                     if (PARS.WBACK) ddd = 11;
  2575.                     else ddd = 10;
  2576.                     }
  2577.                 RGBForeColor(&vcol[cc[Ec]][ddd]);
  2578.                 LineTo (XX, YY);
  2579.                 }
  2580.             mem = FreeMem ();
  2581.             if (mem < 20000)
  2582.                 {
  2583.                 ClosePicture();
  2584.                 KillPicture (thepic);
  2585.                 died ("Ran out of memory", Ec, 602);
  2586.                 }
  2587.             }
  2588.         
  2589.         if (PARS.PARALLEL)
  2590.             B = -PARS.STangle * DEGTORAD * 0.5;
  2591.         else
  2592.             B  = PARS.STangle * DEGTORAD * 0.5;
  2593.         
  2594.         CX = 1;
  2595.         SX = 0;
  2596.         CY = 1;
  2597.         SY = 0;
  2598.         CZ = cos(B);
  2599.         SZ = sin(B);
  2600.         
  2601.         /* rotation matrix for x[y[z[rot]]] */
  2602.         AM =  CY*CZ;
  2603.         BM =  CY*SZ;
  2604.         CM =  -SY;
  2605.         DM =  SX*SY*CZ-CX*SZ;
  2606.         EM =  SX*SY*SZ+CX*CZ;
  2607.         FM =  SX*CY;
  2608.         GM =  CX*SY*CZ+SX*SZ;
  2609.         HM =  CX*SY*SZ-SX*CZ;
  2610.         IM =  CX*CY;
  2611.     
  2612.         for (Ec = 0; Ec < N; Ec++)
  2613.             {
  2614.             goball();
  2615.             X = aaa[Ec].a[0];
  2616.             Y = aaa[Ec].a[1];
  2617.             Z = aaa[Ec].a[2];
  2618.             
  2619.             if (PARS.CHIR) Y = -Y;
  2620.             
  2621.             /* rotate the point */
  2622.             X3 = AM * X + BM * Y + CM * Z;
  2623.             Y3 = DM * X + EM * Y + FM * Z;
  2624.             Z3 = GM * X + HM * Y + IM * Z;
  2625.             
  2626.             /* calculate depth of point */
  2627.             dep = (Y3 + 1)/2;
  2628.             
  2629.             if (PARS.PERSPEC) /* perspective is on*/
  2630.                 {
  2631.                 X3 = X3 * (1.0 - 7.0*PARS.PERSPEC/100.0 + 7.0*PARS.PERSPEC*dep/100.0);
  2632.                 Z3 = Z3 * (1.0 - 7.0*PARS.PERSPEC/100.0 + 7.0*PARS.PERSPEC*dep/100.0);
  2633.                 }
  2634.             
  2635.             XX = Wwidth*PARS.dpi/72 - Wwidth*PARS.dpi/288 + W2middle*X3*zoom*PARS.dpi/144 +
  2636.                 PARS.STsep*Wwidth*PARS.dpi/11520;
  2637.             YY = Wheight*PARS.dpi/144 - W2middle*Z3*zoom*PARS.dpi/144;
  2638.             
  2639.             if (cc[Ec] < 0) // a point
  2640.                 {
  2641.                 if (PARS.COLOR)
  2642.                     if (PARS.DEPTHcue) ddd = dep*10;
  2643.                     else ddd = 9;
  2644.                 else
  2645.                     {
  2646.                     if (PARS.WBACK) ddd = 11;
  2647.                     else ddd = 10;
  2648.                     }
  2649.                 SetCPixel( XX, YY, &vcol[-cc[Ec]][ddd]);
  2650.                 }
  2651.             else if (cc[Ec] == 0) // move
  2652.                 {
  2653.                 MoveTo (XX, YY);
  2654.                 }
  2655.             else // a line
  2656.                 {
  2657.                 if (PARS.COLOR)
  2658.                     if (PARS.DEPTHcue) ddd = dep*10;
  2659.                     else ddd = 9;
  2660.                 else
  2661.                     {
  2662.                     if (PARS.WBACK) ddd = 11;
  2663.                     else ddd = 10;
  2664.                     }
  2665.                 RGBForeColor(&vcol[cc[Ec]][ddd]);
  2666.                 LineTo (XX, YY);
  2667.                 }
  2668.             mem = FreeMem ();
  2669.             if (mem < 20000)
  2670.                 {
  2671.                 ClosePicture();
  2672.                 KillPicture (thepic);
  2673.                 died ("Ran out of memory", Ec, 603);
  2674.                 }
  2675.             }
  2676.         }
  2677.     RGBForeColor(&black);
  2678.     InitCursor();
  2679. }
  2680.  
  2681. //************************************************************************
  2682.  
  2683. void savepict (Boolean vector)
  2684. {
  2685.     static Point SFPwhere = {150, 150};
  2686.     static StandardFileReply reply;
  2687.     long longCount = 1;
  2688.     short globalRef;
  2689.     long i;
  2690.     ResType theType = 'PICT';
  2691.     OpenCPicParams picheader;
  2692.     char name[256], zero = 0;
  2693.     
  2694.     for (i=1;i<=myFSS.name[0];i++)
  2695.         name[i] = myFSS.name[i];
  2696.     if (vector)
  2697.         {
  2698.         i = myFSS.name[0];
  2699.         name[++i] = '.';
  2700.         name[++i] = 'v';
  2701.         name[++i] = 'e';
  2702.         name[++i] = 'c';        
  2703.         name[++i] = 't';
  2704.         name[++i] = 'o';
  2705.         name[++i] = 'r';
  2706.         name[0] = i;
  2707.         }
  2708.     else
  2709.         {
  2710.         i = myFSS.name[0];
  2711.         name[++i] = '.';
  2712.         name[++i] = 'b';
  2713.         name[++i] = 'i';
  2714.         name[++i] = 't';        
  2715.         name[++i] = 'm';
  2716.         name[++i] = 'a';
  2717.         name[++i] = 'p';
  2718.         name[0] = i;
  2719.         }
  2720.     
  2721.     StandardPutFile ("\pSave Pict File as:", (StringPtr)name, &reply);
  2722.     
  2723.     if (reply.sfGood)
  2724.         {
  2725.         rotate();
  2726.         
  2727.         if (vector)
  2728.             {
  2729.             SetRect (&frameRectDPI, 0, 0, (Wwidth+1)*PARS.dpi/72, (Wheight+1)*PARS.dpi/72);
  2730.             picheader.srcRect = frameRectDPI;
  2731.             picheader.hRes = PARS.dpi << 16;
  2732.             picheader.vRes = PARS.dpi << 16;
  2733.             picheader.version = -2;
  2734.             picheader.reserved1 = 0;
  2735.             picheader.reserved2 = 0;
  2736.             }
  2737.         else
  2738.             {
  2739.             picheader.srcRect = frameRect;
  2740.             picheader.hRes = 72 << 16;
  2741.             picheader.vRes = 72 << 16;
  2742.             picheader.version = -2;
  2743.             picheader.reserved1 = 0;
  2744.             picheader.reserved2 = 0;
  2745.             }
  2746.         
  2747.         thepic = OpenCPicture (&picheader);
  2748.         
  2749.         if (vector)
  2750.             {
  2751.             ClipRect(&frameRectDPI);
  2752.             vectorcopy();
  2753.             }
  2754.         else
  2755.         CopyBits((BitMapPtr)drawPixMapP, (BitMapPtr)windowPixMapP,
  2756.             &frameRect, &frameRect, srcCopy, nil);
  2757.         
  2758.         ClosePicture();
  2759.         
  2760.         ClipRect(&frameRect);
  2761.         
  2762.         DrawPicture (thepic, &frameRect);
  2763.         
  2764.         err = FSpCreate (&reply.sfFile, 'ttxt', 'PICT', reply.sfScript);
  2765.         
  2766.         if (err && err != -48) died ("Could not Create File", err, 701);
  2767.         if (err == -48) // file already exists
  2768.             {
  2769.             err = FSpDelete (&reply.sfFile);
  2770.             if (err && err != -45) died ("Could not Update File", err, 702);
  2771.             if (err) Alert(137,NULL);
  2772.             else
  2773.                 {
  2774.                 err = FSpCreate (&reply.sfFile, 'ttxt', 'PICT', reply.sfScript);
  2775.                 if (err) died ("Could not Overwrite File", err, 703);
  2776.                 }
  2777.             }
  2778.         
  2779.         if (!err)
  2780.             {
  2781.             // open the file
  2782.             err = FSpOpenDF (&reply.sfFile, fsRdWrPerm, &globalRef);
  2783.             if (err) died ("Could not Open File", err, 704);
  2784.             
  2785.             longCount = 1;
  2786.             for (i=0; i<512; i++) // write 512 zeros
  2787.                 FSWrite (globalRef, &longCount, &zero);
  2788.             
  2789.             HLock ((Handle)(thepic));
  2790.             longCount = GetHandleSize ((Handle)thepic);
  2791.             FSWrite (globalRef, &longCount, (Ptr)(*thepic));
  2792.             FSClose (globalRef);
  2793.             HUnlock ((Handle)(thepic));
  2794.             }
  2795.         
  2796.         KillPicture (thepic);
  2797.         }
  2798. }
  2799.  
  2800. //************************************************************************
  2801.  
  2802. void readprefs (void)
  2803. {
  2804.     short refnum;
  2805.     long dirid, siz;
  2806.     FSSpec spec;
  2807.     
  2808.     // set up reasonable defaults
  2809.     PARS.WINleft = 10;
  2810.     PARS.WINtop = 50;
  2811.     PARS.WINright = 210;
  2812.     PARS.WINbottom = 250;
  2813.     
  2814.     PARS.INFOleft = 220;
  2815.     PARS.INFOtop = 50;
  2816.     
  2817.     PARS.PERSPEC = 3; // perspective is on
  2818.     PARS.DEPTHcue = TRUE; // depth cueing is on
  2819.     PARS.COLOR = TRUE; // colored image
  2820.     PARS.WBACK = FALSE; // black background
  2821.     PARS.BIGDOTS = 1; //small dots
  2822.     PARS.CHIR = TRUE; // right hand system
  2823.     PARS.STEREO = FALSE; // no stereo
  2824.     PARS.PARALLEL = FALSE; // crosseyed stereo
  2825.     PARS.STangle = 6; // stereo angle = 3 degrees
  2826.     PARS.STsep = 0; // normal stereo seperation
  2827.     PARS.dpi = 300; // 300 dpi pict
  2828.     PARS.KIND = 1; // crosseyed stereo
  2829.     PARS.GRAB = TRUE; // grab and spin
  2830.     PARS.LINE = 1; // line width of 1
  2831.     PARS.HIDDEN = TRUE; // hide lines
  2832.     PARS.INFO = TRUE; // show info window
  2833.     PARS.FUNKY = FALSE; // no wierd traces
  2834.     
  2835.     PARS.MAXwidth = 640;
  2836.     PARS.MAXheight = 460;
  2837.     
  2838.     PARS.ROTYPE = 1; // trackball rotation
  2839.     PARS.SHANGS = FALSE; // dont show angles
  2840.     
  2841.     err = FindFolder (kOnSystemDisk, kPreferencesFolderType,
  2842.         kCreateFolder, &refnum, &dirid);
  2843.     if (err) died ("Could not find preferences folder", err, 801);
  2844.     
  2845.     err = FSMakeFSSpec (refnum, dirid, "\pRotater Prefs", &spec);
  2846.     if (err != 0 && err != -43) died ("Could not make FSSpec", err, 802);
  2847.     
  2848.     if (!err) // prefs file exists
  2849.         {
  2850.         // read in prefs
  2851.         err = FSpOpenDF (&spec, fsRdWrPerm, &refnum);
  2852.         if (err) died ("Could not Open prefs file", err, 803);
  2853.         
  2854.         siz = sizeof(PARS);
  2855.         err = FSRead (refnum, &siz, &PARS);
  2856.         // IGNORE errors so we can read old shorter Prefs files
  2857.         //if (err) died ("Old Prefs file found - Please delete manually", err, 804);
  2858.         //if (siz != sizeof(PARS)) died ("Old Prefs file found - Please delete manually", err, 805);
  2859.         
  2860.         FSClose (refnum);
  2861.         }
  2862.     
  2863.     if (!PARS.BIGDOTS) PARS.BIGDOTS = 1; // fix for old prefs files
  2864.     
  2865.     updatemenus();
  2866. }
  2867.  
  2868. //************************************************************************
  2869.  
  2870. void writeprefs (void)
  2871. {
  2872.     short refnum;
  2873.     long dirid, siz;
  2874.     FSSpec spec;
  2875.     
  2876.     err = FindFolder (kOnSystemDisk, kPreferencesFolderType,
  2877.         kCreateFolder, &refnum, &dirid);
  2878.     if (err) died ("Could not find preferences folder", err, 806);
  2879.     
  2880.     err = FSMakeFSSpec (refnum, dirid, "\pRotater Prefs", &spec);
  2881.     if (err != 0 && err != -43) died ("Could not make FSSpec", err, 807);
  2882.     
  2883.     if (err != -43) // file exists
  2884.         {
  2885.         err = FSpDelete (&spec); // delete it
  2886.         if (err) died ("Could not Delete old prefs file", err, 808);
  2887.         }
  2888.     
  2889.     // create new file
  2890.     err = FSpCreate (&spec, 'KrOt', 'PrEf', smSystemScript);
  2891.     if (err) died ("Could not Create prefs file", err, 809);
  2892.     
  2893.     err = FSpOpenDF (&spec, fsRdWrPerm, &refnum);
  2894.     if (err) died ("Could not Open prefs file", err, 810);
  2895.     
  2896.     siz = sizeof(PARS);
  2897.     err = FSWrite (refnum, &siz, &PARS);
  2898.     if (err) died ("Could not write to file", err, 811);
  2899.     if (siz != sizeof(PARS)) died ("Error writing Pref Info", err, 812);
  2900.     
  2901.     FSClose (refnum);
  2902. }
  2903.  
  2904. //************************************************************************
  2905.  
  2906. void rotatestereoRB (void)
  2907. {
  2908.     double     X, Y, Z, X3, Y3, Z3, X3b, Y3b, Z3b;
  2909.     double    CZ, SZ, CY, SY, CX, SX, CZb, SZb;
  2910.     double    AM, BM, CM, DM, EM, FM, GM, HM, IM;
  2911.     double    Ldep, Ldepb;
  2912.     double    P, B, H, Bb;
  2913.     double  tempWidth, tempHeight, tempZoom, tempPerspec;
  2914.     long    i, j, XX, YY, XX1=0, YY1=0, XXb, YYb, XX1b=0, YY1b=0;
  2915.     long    LEc, currcolor, LWheight=Wheight, LWwidth=Wwidth;
  2916.     long    bigdots=PARS.BIGDOTS;
  2917.     Byte    STr, STb_or_g, STredb_or_g, STbackground;
  2918.     Byte *cbase, *cbaseb;
  2919.     struct Aray *paaa;
  2920.     
  2921.     if(PARS.WBACK)
  2922.     {
  2923.         STbackground=STwhite; STb_or_g=STWred;
  2924.         if (PARS.KIND == 3)// red blue
  2925.             {    STr=STWblue; STredb_or_g=STWredblue; }
  2926.         else
  2927.             {    STr=STWgreen; STredb_or_g=STWredgreen; }
  2928.     }
  2929.     else
  2930.     {
  2931.         STbackground=STblack; STr=STred;
  2932.         if (PARS.KIND == 3)// red blue
  2933.             {    STb_or_g=STblue; STredb_or_g=STredblue; }
  2934.         else
  2935.             {    STb_or_g=STgreen; STredb_or_g=STredgreen; }
  2936.     }
  2937.     
  2938.     P  = DEGTORAD * Xangle;
  2939.     H  = DEGTORAD * Yangle;
  2940.     B  = DEGTORAD * Zangle;
  2941.     Bb =-DEGTORAD * PARS.STangle *.5; // left eye red
  2942.     
  2943.     CX = cos(P);
  2944.     SX = sin(P);
  2945.     CY = cos(H);
  2946.     SY = sin(H);
  2947.     CZ = cos(B);
  2948.     SZ = sin(B);
  2949.     CZb= cos(Bb);
  2950.     SZb= sin(Bb);
  2951.     
  2952.     /* rotation matrix for x[y[z[rot]]] */
  2953.     AM =  CY*CZ;
  2954.     BM =  CY*SZ;
  2955.     CM =  -SY;
  2956.     DM =  SX*SY*CZ-CX*SZ;
  2957.     EM =  SX*SY*SZ+CX*CZ;
  2958.     FM =  SX*CY;
  2959.     GM =  CX*SY*CZ+SX*SZ;
  2960.     HM =  CX*SY*SZ-SX*CZ;
  2961.     IM =  CX*CY;
  2962.     
  2963.     tempZoom    =(double)(Wmiddle)*zoom*.5;
  2964.     tempWidth    =(double)(LWwidth)*.5;
  2965.     tempHeight    =(double)(LWheight)*.5;
  2966.     tempPerspec    =((double)PARS.PERSPEC*.07);
  2967.     
  2968.     for (LEc = 0; LEc < N; LEc++)
  2969.         {
  2970.         currcolor=cc[LEc];
  2971.         //rotate a point
  2972.         paaa=aaa+LEc;
  2973.         if (PARS.CHIR)
  2974.             {
  2975.             X = paaa->a[0];
  2976.             Y = -paaa->a[1];
  2977.             Z = paaa->a[2];
  2978.             X3 = AM * X + BM * Y + CM * Z;
  2979.             Y3 = DM * X + EM * Y + FM * Z;
  2980.             Z3 = GM * X + HM * Y + IM * Z;
  2981.             if (PARS.ROTYPE == 1)
  2982.                 {
  2983.                 paaa->a[0] = X3;
  2984.                 paaa->a[1] = -Y3;
  2985.                 paaa->a[2] = Z3;
  2986.                 }
  2987.             }
  2988.         else
  2989.             { 
  2990.             X = paaa->a[0];
  2991.             Y = paaa->a[1];
  2992.             Z = paaa->a[2];
  2993.             X3 = AM * X + BM * Y + CM * Z;
  2994.             Y3 = DM * X + EM * Y + FM * Z;
  2995.             Z3 = GM * X + HM * Y + IM * Z;
  2996.             if (PARS.ROTYPE == 1)
  2997.                 {
  2998.                 paaa->a[0] = X3;
  2999.                 paaa->a[1] = Y3;
  3000.                 paaa->a[2] = Z3;
  3001.                 }
  3002.             }
  3003.         X3b = CZb * X3 + SZb * Y3;
  3004.         Y3b = -SZb * X3 + CZb * Y3;
  3005.         Z3b = Z3;
  3006.         
  3007.         // calculate depth of point
  3008.         Ldep = Y3 * 0.5 + 0.5;
  3009.         Ldepb= Y3b* 0.5 + 0.5;
  3010.         
  3011.         // take perspective into account
  3012.         Y3 = 1.0 - tempPerspec*(1.0 - Ldep);
  3013.         Y3b= 1.0 - tempPerspec*(1.0 - Ldepb);
  3014.         X3 *= Y3;       X3b*= Y3b;
  3015.         Z3 *= Y3;       Z3b*= Y3b;
  3016.         
  3017.         // 3D -> 2D
  3018.         XX = tempWidth  + X3*tempZoom;
  3019.         YY = tempHeight - Z3*tempZoom;
  3020.         XXb= tempWidth  + X3b*tempZoom;
  3021.         YYb= tempHeight - Z3b*tempZoom;
  3022.         
  3023.         if (currcolor < 0) // a point
  3024.             {
  3025.             XX -= (bigdots>>1);
  3026.             YY -= (bigdots>>1);
  3027.             XXb-= (bigdots>>1);
  3028.             YYb-= (bigdots>>1);
  3029.             for (j=0;j<bigdots;j++,YY++,YYb++)
  3030.                 for (cbase=base+rb*YY+XX, cbaseb=base+rb*YYb+XXb, i=0;i<bigdots;i++)
  3031.                     {
  3032.                     if (YY < LWheight && YY >= 0 && XX+i < LWwidth && XX+i >= 0)
  3033.                         {
  3034.                         if (cbase[i] == STbackground) cbase[i] = STr;
  3035.                         else if (cbase[i] == STb_or_g) cbase[i] = STredb_or_g;
  3036.                         }
  3037.                     if (YYb < LWheight && YYb >= 0 && XXb+i <LWwidth && XXb+i >= 0)
  3038.                         {
  3039.                         if (cbaseb[i] == STbackground) cbaseb[i] = STb_or_g;
  3040.                         else if (cbaseb[i] == STr) cbaseb[i] = STredb_or_g;
  3041.                         }
  3042.                     }
  3043.             }
  3044.         else
  3045.             {
  3046.             if (currcolor) // a line
  3047.                 {
  3048.                 plotlineRB (STr, STredb_or_g, STbackground, XX, XX1, YY, YY1);
  3049.                 plotlineRB (STb_or_g, STredb_or_g, STbackground, XXb, XX1b, YYb, YY1b); // red blue
  3050.                 }
  3051.             XX1 = XX; XX1b = XXb; // move
  3052.             YY1 = YY; YY1b = YYb;
  3053.             }
  3054.         }
  3055. }
  3056.  
  3057. //************************************************************************
  3058.  
  3059. void plotlineRB (Byte col, Byte mix, Byte bkgd, long x, long x1, long y, long y1) // handles overlapping colors
  3060. {
  3061.     long i, k;
  3062.     long LWwidth=Wwidth,LWheight=Wheight,Lrb=rb,line=PARS.LINE,halfline=(line>>1);
  3063.     int r, dx, dy;
  3064.     Byte *cbase;
  3065.     
  3066.     // make x <= x1
  3067.     if (x > x1) { i = x1; x1 = x; x = i; i = y1; y1 = y; y = i; }
  3068.     
  3069.     dx = (x1-x)*2; dy = (y1-y)*2; // << 1
  3070.     
  3071.     if (dy >= 0) //positive line
  3072.         {
  3073.         if (dx > dy) // x longer
  3074.             {
  3075.             if(x1>=LWwidth-1) x1=LWwidth-1;
  3076.             r = dy - (dx>>1); dx -= dy;
  3077.             for (;x<=x1;x++)
  3078.                 {
  3079.                 if (x >= 0)
  3080.                     {
  3081.                     i = y - halfline; k = i + line;
  3082.                     if(i<0) i=0;
  3083.                     if(k>LWheight) k=LWheight;
  3084.                     for(cbase=base+Lrb*i + x;i<k;i++,cbase+=Lrb)
  3085.                     {
  3086.                      if (*cbase == bkgd) *cbase = col;
  3087.                      else if (*cbase != col && *cbase != mix) *cbase = mix;
  3088.                     }
  3089.                     }
  3090.                 if (r >= 0) { y++; r -= dx; }
  3091.                 else r += dy;
  3092.                 }
  3093.             }
  3094.         else // y longer
  3095.             {
  3096.             if(y1>=LWheight-1) y1=LWheight-1;
  3097.             r = dx - (dy>>1); dy -= dx;
  3098.             for (;y<=y1;y++)
  3099.                 {
  3100.                 if (y >= 0)
  3101.                     {
  3102.                     i = x - halfline; k = i + line;
  3103.                     if(i<0) i=0;
  3104.                     if(k>LWwidth) k=LWwidth;
  3105.                     for(cbase=base+Lrb*y;i<k;i++)
  3106.                     {
  3107.                      if (cbase[i] == bkgd) cbase[i] = col;
  3108.                      else if (cbase[i] != col && cbase[i] != mix) cbase[i] = mix;
  3109.                     }
  3110.                     }
  3111.                 if (r >= 0) { x++; r -= dy; }
  3112.                 else r += dx;
  3113.                 }
  3114.             }
  3115.         }
  3116.     else //negative line
  3117.         {
  3118.         dy=-dy;
  3119.         if (dx > dy) // x longer
  3120.             {
  3121.             if(x1>=LWwidth-1) x1=LWwidth-1;
  3122.             r = dy - (dx>>1); dx -= dy;
  3123.             for (;x<=x1;x++)
  3124.                 {
  3125.                 if (x >= 0)
  3126.                     {
  3127.                     i = y - halfline; k = i + line;
  3128.                     if(i<0) i=0;
  3129.                     if(k>LWheight) k=LWheight;
  3130.                     for(cbase=base+Lrb*i + x;i<k;i++,cbase+=Lrb)
  3131.                     {
  3132.                      if (*cbase == bkgd) *cbase = col;
  3133.                      else if (*cbase != col && *cbase != mix) *cbase = mix;
  3134.                     }
  3135.                     }
  3136.                 if (r >= 0) { y--; r -= dx; }
  3137.                 else r += dy;
  3138.                 }
  3139.             }
  3140.         else // y longer
  3141.             {
  3142.             if(y>=LWheight-1) y=LWheight-1;
  3143.             r = dx - (dy>>1); dy -= dx;
  3144.             for (;y1<=y;y1++)
  3145.                 {
  3146.                 if (y1 >= 0)
  3147.                     {
  3148.                     i = x1 - halfline; k = i + line;
  3149.                     if(i<0) i=0;
  3150.                     if(k>LWwidth) k=LWwidth;
  3151.                     for(cbase=base+Lrb*y1;i<k;i++)
  3152.                     {
  3153.                      if (cbase[i] == bkgd) cbase[i] = col;
  3154.                      else if (cbase[i] != col && cbase[i] != mix) cbase[i] = mix;
  3155.                     }
  3156.                     }
  3157.                 if (r >= 0) { x1--; r -= dy; }
  3158.                 else r += dx;
  3159.                 }
  3160.             }
  3161.         }
  3162. }
  3163.  
  3164. //************************************************************************
  3165.  
  3166. void updatemenus (void)
  3167. {
  3168.     long i;
  3169.     
  3170.     HiliteMenu(0);
  3171.     
  3172.     // perspective submenu
  3173.     for (i=1;i<=11;i++) CheckItem (persmenu, i, FALSE);
  3174.     CheckItem (persmenu, PARS.PERSPEC+1, TRUE);
  3175.     
  3176.     // view ticks
  3177.     if (PARS.DEPTHcue) CheckItem (viewmenu, 4, TRUE); else CheckItem (viewmenu, 4, FALSE);
  3178.     if (PARS.HIDDEN) CheckItem (viewmenu, 5, TRUE); else CheckItem (viewmenu, 5, FALSE);
  3179.     if (PARS.COLOR) CheckItem (viewmenu, 6, TRUE); else CheckItem (viewmenu, 6, FALSE);
  3180.     if (PARS.WBACK) CheckItem (viewmenu, 7, FALSE); else CheckItem (viewmenu, 7, TRUE);
  3181.     if (PARS.FUNKY) CheckItem (viewmenu, 8, TRUE); else CheckItem (viewmenu, 8, FALSE);
  3182.     if (PARS.ROTYPE == 1) CheckItem (actionmenu, 4, TRUE); else CheckItem (actionmenu, 4, FALSE);
  3183.     if (PARS.GRAB) CheckItem (actionmenu, 5, TRUE); else CheckItem (actionmenu, 5, FALSE);
  3184.     if (PARS.INFO) CheckItem (infomenu, 1, TRUE); else CheckItem (infomenu, 1, FALSE);
  3185.     if (PARS.SHANGS) CheckItem (infomenu, 2, TRUE); else CheckItem (infomenu, 2, FALSE);
  3186.  
  3187.     if (PARS.CHIR)
  3188.         {
  3189.         SetItemMark(viewmenu, 10, '•');
  3190.         CheckItem (viewmenu, 11, FALSE);
  3191.         }
  3192.     else
  3193.         {
  3194.         CheckItem (viewmenu, 10, FALSE);
  3195.         SetItemMark(viewmenu, 11, '•');
  3196.         }
  3197.     
  3198.     if (PARS.STEREO)
  3199.         {
  3200.         CheckItem (viewmenu, 13, FALSE);
  3201.         SetItemMark(viewmenu, 14, '•');
  3202.         }
  3203.     else
  3204.         {
  3205.         SetItemMark(viewmenu, 13, '•');
  3206.         CheckItem (viewmenu, 14, FALSE);
  3207.         }
  3208.     
  3209.     for (i=1;i<=4;i++) CheckItem (stereomenu, i, FALSE);
  3210.     SetItemMark (stereomenu, PARS.KIND, '•');
  3211.     
  3212.     // dot size submenu
  3213.     for (i=1;i<=11;i++) CheckItem (dotmenu, i, FALSE);
  3214.     CheckItem (dotmenu, PARS.BIGDOTS, TRUE);
  3215.     
  3216.     // line width submenu
  3217.         for (i=1;i<=10;i++) CheckItem (linemenu, i, FALSE);
  3218.         CheckItem (linemenu, PARS.LINE, TRUE);
  3219.     
  3220.     // angle submenu
  3221.     for (i=1;i<=21;i++) CheckItem (anglemenu, i, FALSE);
  3222.     CheckItem (anglemenu, PARS.STangle+1, TRUE);
  3223.     
  3224.     EnableItem (infomenu, 1);
  3225.     EnableItem (viewmenu, 7);
  3226.     
  3227.     if (PARS.STEREO && PARS.KIND > 2)
  3228.         {
  3229.         DisableItem (stereomenu, 10);
  3230.         DisableItem (stereomenu, 11);
  3231.         DisableItem (viewmenu, 4);
  3232.         DisableItem (viewmenu, 5);
  3233.         DisableItem (viewmenu, 6);
  3234.         }
  3235.     else
  3236.         {
  3237.         EnableItem (stereomenu, 10);
  3238.         EnableItem (stereomenu, 11);
  3239.         EnableItem (viewmenu, 4);
  3240.         EnableItem (viewmenu, 5);
  3241.         EnableItem (viewmenu, 6);
  3242.         }
  3243.     
  3244.     if (N) // file is open
  3245.         {
  3246.         EnableItem(filemenu, 2); // Close
  3247.         EnableItem(filemenu, 3); // give icon
  3248.         EnableItem(filemenu, 4); // save bitmap pict
  3249.         EnableItem(filemenu, 5); // save vector pict
  3250.         EnableItem(editmenu, 2); // copy
  3251.         EnableItem(viewmenu, 0); // view menu
  3252.         EnableItem(actionmenu, 0); // action menu
  3253.         EnableItem(infomenu, 2); // show angles test
  3254.         EnableItem(infomenu, 4); // speed test
  3255.         if (PARS.STEREO) EnableItem(stereomenu, 0); else DisableItem(stereomenu, 0);
  3256.         if (hasicon) DisableItem(filemenu, 3); else EnableItem(filemenu, 3);
  3257.         if (PARS.STEREO && PARS.KIND > 2) DisableItem (filemenu, 5);
  3258.             else EnableItem (filemenu, 5);
  3259.         }
  3260.     else // no file open
  3261.         {
  3262.         DisableItem(filemenu, 2);
  3263.         DisableItem(filemenu, 3);
  3264.         DisableItem(filemenu, 4);
  3265.         DisableItem(filemenu, 5);
  3266.         DisableItem(editmenu, 2);
  3267.         DisableItem(viewmenu, 0);
  3268.         DisableItem(stereomenu, 0);
  3269.         DisableItem(actionmenu, 0);
  3270.         DisableItem(infomenu, 2); // show angles
  3271.         DisableItem(infomenu, 4); // speed test
  3272.         }
  3273.         
  3274.     DrawMenuBar();
  3275. }
  3276.  
  3277. //************************************************************************
  3278.  
  3279. void cooldot (long XX, long YY, long col, double dep, long ugh) // splat ball pixels to the Gworld
  3280. {
  3281.     static long tabi[8]={5,6,7,7,7,7,6,5};
  3282.     long i, j, k, ddd;
  3283.     long Lrb=rb, LWwidth=Wwidth, LWheight=Wheight;
  3284.     Byte *cbase, *cplane;
  3285.  
  3286.     if (PARS.DEPTHcue) ddd = (int)(10.0-dep*11.0);
  3287.     else ddd = 0;
  3288.     XX = XX - 3;
  3289.     YY = YY - 3;
  3290.     cbase=base+Lrb*YY + XX;
  3291.     cplane=plane+ LWwidth*YY + XX;
  3292.     
  3293.     if (XX+7 < LWwidth && XX >= 0 && YY+7 < LWheight && YY >= 0 )
  3294.         {
  3295.         for(j=0;j<=7;j++,YY++,cbase+=Lrb,cplane+=LWwidth)
  3296.             for (k=tabi[j],i=7-k;i<=k;i++)
  3297.                 if (ugh >= cplane[i])
  3298.                     {
  3299.                     cbase[i] = Bred[col][ddd][i][j];
  3300.                     cplane[i] = ugh;
  3301.                     }
  3302.         }
  3303.     else
  3304.         for(j=0;j<=7;j++,YY++,cbase+=Lrb,cplane+=LWwidth) if(YY < LWheight && YY >= 0)
  3305.             for (k=tabi[j],i=7-k;i<=k;i++)
  3306.                 if (XX+i < LWwidth && XX+i >= 0 && ugh >= cplane[i])
  3307.                     {
  3308.                     cbase[i] = Bred[col][ddd][i][j];
  3309.                     cplane[i] = ugh;
  3310.                     }
  3311. }
  3312.  
  3313. //************************************************************************
  3314.  
  3315. void moveit (double amt)
  3316. {
  3317.     long i, j;
  3318.     double max, maybe;
  3319.     struct Aray *paaa;
  3320.     
  3321.     /* get maximum distance of points from origin */
  3322.     max = 0;
  3323.     for (i=0; i<N; i++)
  3324.         {
  3325.         paaa=aaa+i; paaa->a[0] += amt;
  3326.         maybe = paaa->a[0] * paaa->a[0] + paaa->a[1] * paaa->a[1] + paaa->a[2] * paaa->a[2];
  3327.         if (maybe > max) max = maybe;
  3328.         }
  3329.     max=sqrt(max);
  3330.         
  3331.     /* scale the points */
  3332.     if (max != 0) // cant scale points at origin
  3333.     for (i=0; i<N; i++)
  3334.         for (paaa=aaa+i, j=0; j<3; j++)
  3335.             paaa->a[j] = (paaa->a[j] / max) * 0.99999;
  3336.             
  3337.     rotate();
  3338. }
  3339.  
  3340. //************************************************************************
  3341.  
  3342. void centerimage (void)
  3343. {
  3344.     double maxX, maxY, maxZ, minX, minY, minZ, max, maybe;
  3345.     long i, j;
  3346.     struct Aray *paaa;
  3347.     
  3348.     maxX = -1; maxY = -1; maxZ = -1;
  3349.     minX = 1; minY = 1; minZ = 1;
  3350.     
  3351.     for (i = 0; i < N; i++)
  3352.         {
  3353.         paaa=aaa+i;
  3354.         if (paaa->a[0] > maxX) maxX = paaa->a[0];
  3355.         if (paaa->a[1] > maxY) maxY = paaa->a[1];
  3356.         if (paaa->a[2] > maxZ) maxZ = paaa->a[2];
  3357.         if (paaa->a[0] < minX) minX = paaa->a[0];
  3358.         if (paaa->a[1] < minY) minY = paaa->a[1];
  3359.         if (paaa->a[2] < minZ) minZ = paaa->a[2];
  3360.         }
  3361.     
  3362.     /* get maximum distance of points from origin */
  3363.     max = 0;
  3364.     for (i=0; i<N; i++)
  3365.         {
  3366.         paaa=aaa+i;
  3367.         paaa->a[0] -= (maxX + minX)/2;
  3368.         paaa->a[1] -= (maxY + minY)/2;
  3369.         paaa->a[2] -= (maxZ + minZ)/2;        
  3370.         maybe = paaa->a[0] * paaa->a[0] + paaa->a[1] * paaa->a[1] + paaa->a[2] * paaa->a[2];
  3371.         if (maybe > max) max = maybe;
  3372.         }
  3373.     max=sqrt(max);
  3374.         
  3375.     /* scale the points */
  3376.     if (max != 0) // cant scale points at origin
  3377.     for (i=0; i<N; i++)
  3378.         for (paaa=aaa+i, j=0; j<3; j++)
  3379.             paaa->a[j] = (paaa->a[j] / max) * 0.99999;
  3380. }
  3381.  
  3382. //************************************************************************
  3383.  
  3384. void maxwindowsize (void)
  3385. {
  3386.     switch (Alert(139,NULL))
  3387.         {
  3388.         case 1: // cancel
  3389.             break;
  3390.         case 2: // 200x200
  3391.             PARS.MAXwidth = 200;
  3392.             PARS.MAXheight = 200;
  3393.             writeprefs();
  3394.             break;
  3395.         case 3: // classic
  3396.             PARS.MAXwidth = 512;
  3397.             PARS.MAXheight = 332;
  3398.             writeprefs();
  3399.             break;
  3400.         case 4: // 12"
  3401.             PARS.MAXwidth = 512;
  3402.             PARS.MAXheight = 364;
  3403.             writeprefs();
  3404.             break;
  3405.         case 5: // 640x400
  3406.             PARS.MAXwidth = 640;
  3407.             PARS.MAXheight = 380;
  3408.             writeprefs();
  3409.             break;
  3410.         case 6: // 13"
  3411.             PARS.MAXwidth = 640;
  3412.             PARS.MAXheight = 460;
  3413.             writeprefs();
  3414.             break;
  3415.         case 7: // full 640x480
  3416.             PARS.MAXwidth = 640;
  3417.             PARS.MAXheight = 480;
  3418.             writeprefs();
  3419.             break;
  3420.         case 8: // portrait
  3421.             PARS.MAXwidth = 640;
  3422.             PARS.MAXheight = 850;
  3423.             writeprefs();
  3424.             break;
  3425.         case 9: // 16"
  3426.             PARS.MAXwidth = 832;
  3427.             PARS.MAXheight = 604;
  3428.             writeprefs();
  3429.             break;
  3430.         case 10: // 19"
  3431.             PARS.MAXwidth = 1024;
  3432.             PARS.MAXheight = 748;
  3433.             writeprefs();
  3434.             break;
  3435.         case 11: // 21"
  3436.             PARS.MAXwidth = 1182;
  3437.             PARS.MAXheight = 850;
  3438.             writeprefs();
  3439.             break;
  3440.         }
  3441. }
  3442.  
  3443. //************************************************************************
  3444.  
  3445. void setdpi (void)
  3446. {
  3447.     long i;
  3448.     
  3449.     i = Alert(200,NULL);
  3450.     
  3451.     switch (i)
  3452.         {
  3453.         case 1: // cancel
  3454.             break;
  3455.         case 2:
  3456.             PARS.dpi = 72;
  3457.             break;
  3458.         case 3:
  3459.             PARS.dpi = 75;
  3460.             break;
  3461.         case 4:
  3462.             PARS.dpi = 150;
  3463.             break;
  3464.         case 5:
  3465.             PARS.dpi = 288;
  3466.             break;
  3467.         case 6:
  3468.             PARS.dpi = 300;
  3469.             break;
  3470.         case 7:
  3471.             PARS.dpi = 360;
  3472.             break;
  3473.         case 8:
  3474.             PARS.dpi = 576;
  3475.             break;
  3476.         case 9:
  3477.             PARS.dpi = 600;
  3478.             break;
  3479.         case 10:
  3480.             PARS.dpi = 800;
  3481.             break;
  3482.         case 11:
  3483.             PARS.dpi = 1200;
  3484.             break;
  3485.         case 12:
  3486.             PARS.dpi = 1500;
  3487.             break;
  3488.         case 13:
  3489.             PARS.dpi = 2400;
  3490.             break;
  3491.         }
  3492.     if (i != 1) savepict(TRUE);
  3493. }
  3494.  
  3495. //************************************************************************
  3496.  
  3497. void showangles (void)
  3498. {
  3499.     Str255 tempStr;
  3500.     
  3501.     SetGWorld(drawWorldP, nil);
  3502.     
  3503.     if (!PARS.WBACK) RGBForeColor (&white);
  3504.     else RGBForeColor (&black);
  3505.  
  3506.     MoveTo (3, 10);
  3507.     DrawString ("\pX angle = ");    
  3508.     NumToString (Xangle, tempStr);
  3509.     DrawString (tempStr);
  3510.     
  3511.     MoveTo (3, 20);
  3512.     DrawString ("\pY angle = ");    
  3513.     NumToString (Yangle, tempStr);
  3514.     DrawString (tempStr);
  3515.     
  3516.     MoveTo (4, 30);
  3517.     DrawString ("\pZ angle = ");    
  3518.     NumToString (Zangle, tempStr);
  3519.     DrawString (tempStr);
  3520.  
  3521.     SetGWorld(saveWorld, saveDevice);
  3522. }
  3523.  
  3524. //************************************************************************
  3525.  
  3526.  
  3527.  
  3528.  
  3529.  
  3530.  
  3531.  
  3532.